diff --git a/python/.vscode/settings.json b/python/.vscode/settings.json new file mode 100644 index 0000000..4cc97ed --- /dev/null +++ b/python/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "cSpell.words": [ + "iloc" + ] +} \ No newline at end of file diff --git a/python/PyData/pandas.md b/python/PyData/pandas.md new file mode 100644 index 0000000..50aa50d --- /dev/null +++ b/python/PyData/pandas.md @@ -0,0 +1,34 @@ +- 读取各种表格文件：`pd.read_*()` + - 文件没有表头时，需指定 `header=None` 参数 + - 为文件修改表头：`header=['', '', ...]`。注意长度需要和表头一致，不能多也不能少 + +- `DataFrame` 对象 + - `values()` 返回二维数组。数据不包括表头信息。 + - `columns` 用于获取/修改表头。 + - `rename()` + - `columns={'old_header_name': 'new_header_name', ...}` 重命名指定表头 + - `inplace=True` 指定为 True 时在原 DataFrame 对象上修改表头 + - `to_*()` 转换为其他类型的表格文件，比如 `to_csv()` + - 第一个参数为文件输出的目录 + - `index=False` 表示不属于索引值，即不会新增一列 + - `iloc[]` 基于位置（第几行、第几列）进行选择。不支持字符串 + - `iloc[ 0:1 , 1:2 ]` 获取 `[0,1)` 行，`[1,2)` 列的内容，返回 DataFrame 对象。 + - `iloc[ 0:1 , : ]` 获取 `[0,1)` 行，所有列的内容。返回 DataFrame 对象 + - `iloc[ : , 0:3 ]` 获取所有行，`[0,3)` 列的内容。返回 DataFrame 对象 + - `iloc[ 0:2 ]` 等同于 `iloc[ 0:2 , : ]`。返回 DataFrame 对象 + - `iloc[ [0,2] , : ]` 获取第 `0`, `2`, `4` 行，所有列的内容，返回 DataFrame 对象。 + - `iloc[ [0,2] ]` 等同 `iloc[ [0,2], : ]`，返回 DataFrame 对象 + - `iloc[ 0 ]` 获取第一行的内容, 返回 `Series` 对象。 + - `iloc[ (0 , 1) ]` 获取第一行第二列的单元格内容，返回类型为该单元格所对应的数据类型，比如 str + - `iloc[ 0 , 1 ]` 等同 `iloc[ (0,1) ]`，返回类型为单元格所对应类型 + - 还支持布尔类型数组，数组大小要求与行或列对应。故一般用在遍历时返回一个布尔值。 + - `loc[]` 根据标签（列表头、行索引）进行选择。 + - 与 `iloc[]` 的区别 + - `loc[0]` 中的数字表示标签，它选择的是所有行索引值为数字 `0` 的那些行（数量不确定），返回一个 DataFrame 对象。 + - 而 `iloc[0]` 中的数字表示的是位置 `0`，无论该行的索引值是什么，它都只会选择第一行，返回一个 `Series` 对象。 +- `Series` 对象 + - `replace()` 批量替换值 + - `to_replace=<旧值>` + - `value=<新值>` + - `inplace=True` 表示在原 Series 对象上修改。 + - `map()` 遍历，暂时没用到，知道有这个方法就行。 \ No newline at end of file diff --git a/python/PyData/pydub.md b/python/PyData/pydub.md new file mode 100644 index 0000000..0cb5c6f --- /dev/null +++ b/python/PyData/pydub.md @@ -0,0 +1,8 @@ +`from pydub import AudioSegment` + +- 读取音频 + - `AudioSegment.from_mp3(<输入路径>)` +- `AudioSegment` 对象 + - `duration_seconds` 查看音频时长 + - `export(<导出路径>, format='mp3')` + - `[:(duration-20) * 1000]` 剪切，单位是毫秒。 \ No newline at end of file diff --git a/python/README.md b/python/README.md new file mode 100644 index 0000000..4e9a5fd --- /dev/null +++ b/python/README.md @@ -0,0 +1,12 @@ +# 学习 Python 基本内容 + +量少，并且容易看懂的标准库 + +- `bisect` +- `heapq` +from collections import deque + +## 可参考网站 + +- [py 基本知识](https://docs.python.org/zh-cn/3.11/tutorial/index.html) +- [Ask Python](https://www.askpython.com/) \ No newline at end of file diff --git a/python/old-note-py-pyData/.gitignore b/python/old-note-py-pyData/.gitignore new file mode 100644 index 0000000..3abfc3b --- /dev/null +++ b/python/old-note-py-pyData/.gitignore @@ -0,0 +1 @@ +AI/resource/creditcard.csv \ No newline at end of file diff --git "a/python/old-note-py-pyData/AI/01-\351\200\273\350\276\221\345\233\236\345\275\222\346\250\241\345\236\213-\344\277\241\347\224\250\345\215\241\346\254\272\350\257\210-1.ipynb" "b/python/old-note-py-pyData/AI/01-\351\200\273\350\276\221\345\233\236\345\275\222\346\250\241\345\236\213-\344\277\241\347\224\250\345\215\241\346\254\272\350\257\210-1.ipynb" new file mode 100644 index 0000000..0bc9d1f --- /dev/null +++ "b/python/old-note-py-pyData/AI/01-\351\200\273\350\276\221\345\233\236\345\275\222\346\250\241\345\236\213-\344\277\241\347\224\250\345\215\241\346\254\272\350\257\210-1.ipynb" @@ -0,0 +1,1734 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 相关概念\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "样本不均匀的解决方法:\n", + " - 下采样\n", + " - 过采样\n", + "\n", + "一份数据一般划分为三部分: \n", + " - 训练集(train): 用于训练模型的参数\n", + " - 验证集(valid): 用于评估模型性能和调优超参数\n", + " - 测试集(test): 评估模型最终的泛化能力\n", + " 注意, 其中的测试集, 可以认为是 \"未来\" 的数据。 我们训练一个模型, 为的就是让他能够对未知的数据进行预测。 \n", + " \n", + "K 折交叉验证的过程一般是这样的:\n", + " 1. 将原始数据集划分为 K 份\n", + " 2. 选取第 i 份作为测试集\n", + " 3. 除了第 i 份数据, 将剩余数据划分为训练集和验证集\n", + " 4. 开始训练, 得到一个模型和一次验证结果\n", + " 5. 总共会重复 k 次重复步骤 2-4。\n", + " 6. 最终可以得到 K 个模型和 K 次验证结果，最终将这些结果取平均值作为模型的性能指标。 \n", + " 注意: K 折交叉验证, 每次训练, 测试集都是不一样的。\n", + "\n", + "交叉验证:\n", + " 除了 K 折交叉验证外, 还有其他类型的交叉验证, 比如:\n", + " - Leave-One-Out(LOO): 留一法交叉验证。 即先从数据集中单独取出测试集, 然后再对剩下的数据划分为 K 折, 每折中再对数据划分为训练集和验证集\n", + " - 嵌套交叉验证的变体: 将数据分为 k 份, 然后在每份数据中再将数据分为 3 份: 训练、验证和测试\n", + " - 嵌套交叉验证: 相当于嵌套 K 折交叉验证, 先将数据划分为 K 份, 每次选取其中一份作为测试集, 此时对剩下的数据再做一次 K 折交叉验证。\n", + " - ... 其他 \n", + " LOO 可以提供更准确的性能评估指标, 但它的计算成本较高, 当数据量非常少的时候, LOO 可能比 K 折交叉验证更合适。 \n", + " 当数据量足够大时, 嵌套交叉可以提供更准确的模型性能评估, 它也要求更高的计算资源。\n", + " 总的来说, 从计算成本和可靠性的角度来看, 通常认为k折交叉验证是更好的选择。\n", + " \n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "TP, TN, FP, FN\n", + " T 和 F 指的是 True, False。 即预测的结果是否正确。\n", + " P 和 N 指的是 Positive, Negative。 P 指的是与我们的目标相符, N 指的与我们的目标不符。 比如检测癌症, 我们的目标就是检测出癌症, 如果检测为没有癌症, 则是 N\n", + " 所以可以这样理解比较方便, 先看是 P 还是 N, 然后再看是对还是错。 \n", + " 下面举多几个例子方便理解:\n", + " - 信用卡欺诈, 我们的 P 是找到欺诈的信用卡。 \n", + " - TP 就是判定为欺诈, 并且判断对了; \n", + " - TN 就是判断为不是欺诈, 结果判定对了; \n", + " - FP 就是判断我欺诈, 结果判断错了;\n", + " - FN 就是判断为不是欺诈, 结果判断错了;\n", + " - 癌症检测, 我们的 P 是检测出癌症\n", + " - TP 就是检测为癌症, 并且检测对了;\n", + " - TN 就是认为没有癌症, 并且确实没有癌症;\n", + " - FP 就是检测为癌症, 但是检测错了;\n", + " - FN 就是认为没有癌症, 但实际上有癌症;\n", + " - 找出狼人, 我们的 P 是找出狼人\n", + " - TP 就是判断为狼人, 并且判断对了;\n", + " - TN 就是判断为平民, 并且判断对了;\n", + " - FP 就是判断为狼人, 但是判断错了。即把平民误判为狼人;\n", + " - FN 就出判断为平民, 但是判断错了。即把狼人错当成平民;\n", + " 这些在实际生活中有什么作用呢? 那就是看需求了, 是要\"宁可错杀一万, 也不放过一个\"呢, 还是要\"疑罪从无\"呢?\n", + " 比如信用卡欺诈, 如果 FP 太大, 则说明误判为欺诈的用户过多, 这可能导致大量用户的账户被冻结, 这是不允许的。\n", + " 所以即使 recall 分数很高, 但如果 FP 太大, 也是不可取的\n", + "\n", + "\n", + "混淆矩阵: 在这里其实指的就是 TP, TN, FP, FN 的可视化结果:\n", + "\n", + " TN FN\n", + " FP TP\n", + "\n", + "模型的度量指标: 常见的有下面几种:\n", + " - 准确率(precision): 预测为该类别的样本数与实际属于该类别的样本数之比。 即 precision = (TP+TN) / (TP+TN+FP+FN); \n", + " $$precision = \\frac{TP+TN}{TP+TN+FP+FN}$$\n", + " - 召回率(recall): 被正确预测为该类别的样本数与实际属于该类别的样本数之比。 即 Recall = TP / (TP + FP); \n", + " $$Recall = \\frac{TP}{TP + FP}$$\n", + " - F1_score: 准确率和召回率的加权平均值。 即 F1_score = 2 * ((precision * recall) / (precision + recall)); \n", + " $$F1\\_score = 2 * \\frac{(precision * recall)}{(precision + recall)}$$\n", + " - 支持度(support): 实际属于该类别的样本数。 即 support = TP + FN; \n", + " $$support = TP + FN$$\n", + "\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "\n", + "\n", + "正则化惩罚项\n", + " loss 是损失函数, loss 越小, 代表效果越好。\n", + " 那么惩罚的方法, 就是让 loss 加上一个值。 比如, 千米跑时, 用时肯定越低越好。 当我们惩罚某人时, 可以让他加上配重跑步, 此时用时就会变大了, 如果负重跑步成绩还非常好的话, 说明它确实很好。\n", + " 这个配重, 就是惩罚项。 比如 L2 的配重就是 0.5w平方; \n", + " L1 惩罚, 就是 w的绝对值\n", + " 但惩罚也是有强度的, 即要给人加上几个配重, 这个值就是 $\\lambda$\n", + "\n", + " scikit-learn 中的 LogisticRegression() 函数, 它的参数叫做 `C`, 这个 c 字母没有具体意义(全称), 可以说它的命名有点随意。 但它表示的是正则化强度的倒数\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "plt.rcParams['font.family'] = ['SimHei']" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 先观察分析数据" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TimeV1V2V3V4V5V6V7V8V9...V21V22V23V24V25V26V27V28AmountClass
00.0-1.359807-0.0727812.5363471.378155-0.3383210.4623880.2395990.0986980.363787...-0.0183070.277838-0.1104740.0669280.128539-0.1891150.133558-0.021053149.620
10.01.1918570.2661510.1664800.4481540.060018-0.082361-0.0788030.085102-0.255425...-0.225775-0.6386720.101288-0.3398460.1671700.125895-0.0089830.0147242.690
21.0-1.358354-1.3401631.7732090.379780-0.5031981.8004990.7914610.247676-1.514654...0.2479980.7716790.909412-0.689281-0.327642-0.139097-0.055353-0.059752378.660
31.0-0.966272-0.1852261.792993-0.863291-0.0103091.2472030.2376090.377436-1.387024...-0.1083000.005274-0.190321-1.1755750.647376-0.2219290.0627230.061458123.500
42.0-1.1582330.8777371.5487180.403034-0.4071930.0959210.592941-0.2705330.817739...-0.0094310.798278-0.1374580.141267-0.2060100.5022920.2194220.21515369.990
\n", + "

5 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " Time V1 V2 V3 V4 V5 V6 V7 \\\n", + "0 0.0 -1.359807 -0.072781 2.536347 1.378155 -0.338321 0.462388 0.239599 \n", + "1 0.0 1.191857 0.266151 0.166480 0.448154 0.060018 -0.082361 -0.078803 \n", + "2 1.0 -1.358354 -1.340163 1.773209 0.379780 -0.503198 1.800499 0.791461 \n", + "3 1.0 -0.966272 -0.185226 1.792993 -0.863291 -0.010309 1.247203 0.237609 \n", + "4 2.0 -1.158233 0.877737 1.548718 0.403034 -0.407193 0.095921 0.592941 \n", + "\n", + " V8 V9 ... V21 V22 V23 V24 V25 \\\n", + "0 0.098698 0.363787 ... -0.018307 0.277838 -0.110474 0.066928 0.128539 \n", + "1 0.085102 -0.255425 ... -0.225775 -0.638672 0.101288 -0.339846 0.167170 \n", + "2 0.247676 -1.514654 ... 0.247998 0.771679 0.909412 -0.689281 -0.327642 \n", + "3 0.377436 -1.387024 ... -0.108300 0.005274 -0.190321 -1.175575 0.647376 \n", + "4 -0.270533 0.817739 ... -0.009431 0.798278 -0.137458 0.141267 -0.206010 \n", + "\n", + " V26 V27 V28 Amount Class \n", + "0 -0.189115 0.133558 -0.021053 149.62 0 \n", + "1 0.125895 -0.008983 0.014724 2.69 0 \n", + "2 -0.139097 -0.055353 -0.059752 378.66 0 \n", + "3 -0.221929 0.062723 0.061458 123.50 0 \n", + "4 0.502292 0.219422 0.215153 69.99 0 \n", + "\n", + "[5 rows x 31 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 链接： https://pan.baidu.com/s/1VMQ64TZL1xPyUExwmK737w?pwd=1111 \n", + "data = pd.read_csv('./resource/creditcard.csv')\n", + "data.head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "观察数据, Time 是没有价值的。\n", + "然后这些数据是信用卡原数据经过脱敏, 降维处理过的, 其中的 V1 ~ V28 都是特征\n", + "然后 Amount 其实也是特征, 不过 Amount 的值相对其他特征来说, 数值偏大, 区间跨区也大, 有 2.69, 也有 378 这种。\n", + "反观其他特征 V, 基本都是 -1 到 1 左右, 数值较小, 区间也不大。\n", + "并且, 我们并不知道哪些特征的权重(重要程度)较大, 所以后面我们还需要处理一下 Amount,\n", + "让每一个特征的权重都尽可能相同, 不然模型可能会认为, Amount 的数值较大, 于是它的重要程度也比较大。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 数据预处理" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 对 Amount 进行数据缩放\n", + "\n", + "先对 Amount 进行一个标准化, 目的是为了让每个特征的权重基本相同。\n", + "\n", + "归一化是数据缩放的一种方式, 标准化是归一化的一种。\n", + "标准化的做法是将数据转换为均值为 0, 方差为 1 的标准正态分布。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.244964\n", + "1 -0.342475\n", + "2 1.160686\n", + "3 0.140534\n", + "4 -0.073403\n", + "Name: normAmount, dtype: float64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# 将 Amount 列(Series)提取出来，转换为 NumPy 数组, 并 reshape 成一个列向量。 -1 表示让其自动计算\n", + "amount = np.array(data['Amount']).reshape(-1, 1) \n", + "# 标准化\n", + "data['normAmount'] = StandardScaler().fit_transform(amount)\n", + "data['normAmount'].head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 删除一些不必要的列" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
V1V2V3V4V5V6V7V8V9V10...V21V22V23V24V25V26V27V28ClassnormAmount
0-1.359807-0.0727812.5363471.378155-0.3383210.4623880.2395990.0986980.3637870.090794...-0.0183070.277838-0.1104740.0669280.128539-0.1891150.133558-0.02105300.244964
11.1918570.2661510.1664800.4481540.060018-0.082361-0.0788030.085102-0.255425-0.166974...-0.225775-0.6386720.101288-0.3398460.1671700.125895-0.0089830.0147240-0.342475
2-1.358354-1.3401631.7732090.379780-0.5031981.8004990.7914610.247676-1.5146540.207643...0.2479980.7716790.909412-0.689281-0.327642-0.139097-0.055353-0.05975201.160686
3-0.966272-0.1852261.792993-0.863291-0.0103091.2472030.2376090.377436-1.387024-0.054952...-0.1083000.005274-0.190321-1.1755750.647376-0.2219290.0627230.06145800.140534
4-1.1582330.8777371.5487180.403034-0.4071930.0959210.592941-0.2705330.8177390.753074...-0.0094310.798278-0.1374580.141267-0.2060100.5022920.2194220.2151530-0.073403
\n", + "

5 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " V1 V2 V3 V4 V5 V6 V7 \\\n", + "0 -1.359807 -0.072781 2.536347 1.378155 -0.338321 0.462388 0.239599 \n", + "1 1.191857 0.266151 0.166480 0.448154 0.060018 -0.082361 -0.078803 \n", + "2 -1.358354 -1.340163 1.773209 0.379780 -0.503198 1.800499 0.791461 \n", + "3 -0.966272 -0.185226 1.792993 -0.863291 -0.010309 1.247203 0.237609 \n", + "4 -1.158233 0.877737 1.548718 0.403034 -0.407193 0.095921 0.592941 \n", + "\n", + " V8 V9 V10 ... V21 V22 V23 V24 \\\n", + "0 0.098698 0.363787 0.090794 ... -0.018307 0.277838 -0.110474 0.066928 \n", + "1 0.085102 -0.255425 -0.166974 ... -0.225775 -0.638672 0.101288 -0.339846 \n", + "2 0.247676 -1.514654 0.207643 ... 0.247998 0.771679 0.909412 -0.689281 \n", + "3 0.377436 -1.387024 -0.054952 ... -0.108300 0.005274 -0.190321 -1.175575 \n", + "4 -0.270533 0.817739 0.753074 ... -0.009431 0.798278 -0.137458 0.141267 \n", + "\n", + " V25 V26 V27 V28 Class normAmount \n", + "0 0.128539 -0.189115 0.133558 -0.021053 0 0.244964 \n", + "1 0.167170 0.125895 -0.008983 0.014724 0 -0.342475 \n", + "2 -0.327642 -0.139097 -0.055353 -0.059752 0 1.160686 \n", + "3 0.647376 -0.221929 0.062723 0.061458 0 0.140534 \n", + "4 -0.206010 0.502292 0.219422 0.215153 0 -0.073403 \n", + "\n", + "[5 rows x 30 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# axis=1 表示按列操作(删除)\n", + "data = data.drop(['Time', 'Amount'], axis=1)\n", + "data.head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 观察 Class\n", + "Class 就是标签, 即该信用卡是否是欺诈的。 我们先看看 Class 中值的分布" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[284315 492]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 对 Class 列进行值计数, 统计不同值出现的次数。 并将这些\"不同值\"作为索引, \"次数\" 作为值, 返回成一个 Series 对象\n", + "count_classes = pd.value_counts( data['Class'], sort=True ).sort_index()\n", + "\n", + "# 绘制柱形图\n", + "ax = count_classes.plot(kind = 'bar', rot=0)\n", + "\n", + "# 在柱形上添加数值标签\n", + "for p in ax.containers:\n", + " ax.bar_label(p, fontsize=14)\n", + "\n", + "plt.title('Class 标签的柱状统计图')\n", + "plt.xlabel('Class 标签值')\n", + "plt.ylabel('出现次数')\n", + "\n", + "print(count_classes.values)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "观察发现, Class 中值为 1 的比例非常低, 现实中欺诈的信用卡比例也是很低的, 所以 1 表示应该是异常样本(欺诈), 0 表示的应该就是正常样本。\n", + "\n", + "样本数量不均匀的情况下, 我们一般有两种处理方式： 过采样和下采样。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 不执行下采样和过采样生成的数据集" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "$\\mathbf{X}$ 是特征矩阵\n", + "\n", + "$\\mathbf{y}$ 是标签向量" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((284807, 29), (284807, 1))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X = data.loc[:, data.columns != 'Class']\n", + "y = data.loc[:, data.columns == 'Class']\n", + "X.shape, y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原始数据集划分\n", + "\t训练数据集数量: 199364\n", + "\t测试数据集数量: 85443\n", + "\t总数据集数量: 284807\n" + ] + } + ], + "source": [ + "# random_state 是为了让每次随机划分的结果相同\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.3, random_state=0)\n", + "print('原始数据集划分')\n", + "print('\\t训练数据集数量: ', len(X_train))\n", + "print('\\t测试数据集数量: ', len(X_test))\n", + "print('\\t总数据集数量: ', len(X_train) + len(X_test))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. 执行下采样生成的数据集" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((984, 29), (984, 1))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 样本中信用卡欺诈数量\n", + "number_records_fraud = len(data[data.Class == 1]) \n", + "# 欺诈样本的索引值\n", + "fraud_indices = np.array(data[data.Class == 1].index)\n", + "\n", + "# 从正常信用卡的样本中随机抽取出一部分数据, 这些数据数量和欺诈的数量相同。 这就叫下采样\n", + "normal_indices = data[data.Class == 0].index\n", + "random_normal_indices = np.random.choice( normal_indices, number_records_fraud, replace=False)\n", + "# 随机抽取到的正常信用卡样本的索引值\n", + "random_normal_indices = np.array(random_normal_indices)\n", + "\n", + "# 将所有欺诈的样本和随机抽取正常的样本合并为新的数据集, 该数据集就是下采样的数据集\n", + "under_sample_indices = np.concatenate([fraud_indices, random_normal_indices])\n", + "under_sample_data = data.iloc[under_sample_indices, :]\n", + "\n", + "# 获取下采样的特征和标签\n", + "X_under_sample = under_sample_data.loc[:, under_sample_data.columns != 'Class' ]\n", + "y_under_sample = under_sample_data.loc[:, under_sample_data.columns == 'Class' ]\n", + "X_under_sample.shape, y_under_sample.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. 执行过采样生成的数据集" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from imblearn.over_sampling import SMOTE # pip install imblearn\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原始样本的分布: [199019 345]\n", + "过采样后样本的分布: [199019 199019]\n" + ] + }, + { + "data": { + "text/plain": [ + "((398038, 29), (398038, 1))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "smote = SMOTE(random_state=0)\n", + "X_over_sample, y_over_sample = smote.fit_resample(X_train, y_train)\n", + "print('原始样本的分布: ', y_train.groupby('Class').size().values)\n", + "print('过采样后样本的分布: ', y_over_sample.groupby('Class').size().values)\n", + "X_over_sample.shape, y_over_sample.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. 划分训练集和测试集" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "下采样处理后的数据集划分\n", + "\t训练数据集数量: 688\n", + "\t测试数据集数量: 296\n", + "\t总数据集数量: 984\n", + "过采样处理后的数据集划分\n", + "\t训练数据集数量: 278626\n", + "\t测试数据集数量: 119412\n", + "\t总数据集数量: 398038\n" + ] + } + ], + "source": [ + "# 下采样处理后的数据集。 虽然我们这里划分除了下采样 的测试集, 但实际上, 我们应该使用原始数据划分出的测试集进行测试。\n", + "X_train_under_sample, X_test_under_sample, y_train_under_sample, y_test_under_sample = train_test_split(\n", + " X_under_sample, y_under_sample, test_size=0.3, random_state=0)\n", + "print('下采样处理后的数据集划分')\n", + "print('\\t训练数据集数量: ', len(X_train_under_sample))\n", + "print('\\t测试数据集数量: ', len(X_test_under_sample))\n", + "print('\\t总数据集数量: ', len(X_train_under_sample) + len(X_test_under_sample))\n", + "\n", + "\n", + "# 过采样\n", + "X_train_over_sample, X_test_over_sample, y_train_over_sample, y_test_over_sample = train_test_split(\n", + " X_over_sample, y_over_sample, test_size=0.3, random_state=0)\n", + "print('过采样处理后的数据集划分')\n", + "print('\\t训练数据集数量: ', len(X_train_over_sample))\n", + "print('\\t测试数据集数量: ', len(X_test_over_sample))\n", + "print('\\t总数据集数量: ', len(X_train_over_sample) + len(X_test_over_sample))\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. 训练模型, 求取最优参数 c" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import KFold, cross_val_score\n", + "from sklearn.metrics import make_scorer, recall_score, confusion_matrix, classification_report\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "求取最优参数 C\n", + "\n", + "K 折交叉验算" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def printing_KFold_scores(X_train_data, y_train_data):\n", + "\n", + " # 这个是正则化惩罚项参数.\n", + " c_param_range = [0.001, 0.01, 0.1, 1, 10]\n", + "\n", + " # K 折\n", + " K = 5\n", + "\n", + " # 创建一个表格存储分数\n", + " original_columns = ['C_parameter', 'Mean recall scores']\n", + " new_columns = [f'score-{i}' for i in range(1, K+1)]\n", + " result_columns = original_columns[:1] + new_columns + original_columns[1:]\n", + " results_table = pd.DataFrame(columns=result_columns)\n", + " j = 0\n", + "\n", + " # 这个循环用来查看哪个 c 参数效果好\n", + " for c_param in c_param_range:\n", + "\n", + " # 创建逻辑回归分类器\n", + " logreg = LogisticRegression(C=c_param, penalty='l2')\n", + "\n", + " # 创建KFold对象\n", + " kfold = KFold(n_splits=K, shuffle=False)\n", + "\n", + " # 创建recall_score评分器\n", + " scorer = make_scorer(recall_score, average='macro')\n", + "\n", + " # 使用交叉验证计算模型的精度\n", + " scores = cross_val_score(\n", + " logreg, X_train_data.values, y_train_data.values.flatten(), cv=kfold, scoring=scorer)\n", + "\n", + " row = pd.Series(\n", + " {'score-' + str(i+1): f'{scores[i]:.3f}' for i in range(len(scores))})\n", + " results_table = pd.concat(\n", + " [results_table, row.to_frame().T], ignore_index=True)\n", + " results_table.loc[j, 'C_parameter'] = c_param\n", + " results_table.loc[j, 'Mean recall scores'] = float(scores.mean())\n", + " j += 1\n", + "\n", + " i_max = results_table['Mean recall scores'].astype(float).idxmax()\n", + " best_score = results_table.loc[i_max, 'Mean recall scores']\n", + " best_c_parameter = results_table.loc[i_max, 'C_parameter']\n", + " \n", + " return best_c_parameter, best_score, results_table\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原始数据作为训练集训练模型" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best_c: 1;\n", + "best_scores: 0.8091666556613513;\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
C_parameterscore-1score-2score-3score-4score-5Mean recall scores
00.0010.6940.7740.8080.7620.6940.746252
10.010.7690.8080.8330.8000.7500.791974
20.10.7760.8080.8580.8080.7810.806253
310.7760.8080.8670.8080.7870.809167
4100.7760.8080.8670.8080.7870.809167
\n", + "
" + ], + "text/plain": [ + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 0.001 0.694 0.774 0.808 0.762 0.694 0.746252\n", + "1 0.01 0.769 0.808 0.833 0.800 0.750 0.791974\n", + "2 0.1 0.776 0.808 0.858 0.808 0.781 0.806253\n", + "3 1 0.776 0.808 0.867 0.808 0.787 0.809167\n", + "4 10 0.776 0.808 0.867 0.808 0.787 0.809167" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_c, best_scores, scores_table = printing_KFold_scores(X_train, y_train)\n", + "print(f'best_c: {best_c};')\n", + "print(f'best_scores: {best_scores};')\n", + "scores_table" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下采样数据集作为训练集训练模型" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best_c_us: 0.1;\n", + "best_scores_us: 0.9343014595137561;\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
C_parameterscore-1score-2score-3score-4score-5Mean recall scores
00.0010.8960.9040.9070.9320.9320.914311
10.010.8880.9250.9450.9580.9390.931036
20.10.9020.9240.9640.9490.9330.934301
310.8860.9380.9490.9490.9330.931004
4100.8780.9380.9490.9490.9260.927888
\n", + "
" + ], + "text/plain": [ + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 0.001 0.896 0.904 0.907 0.932 0.932 0.914311\n", + "1 0.01 0.888 0.925 0.945 0.958 0.939 0.931036\n", + "2 0.1 0.902 0.924 0.964 0.949 0.933 0.934301\n", + "3 1 0.886 0.938 0.949 0.949 0.933 0.931004\n", + "4 10 0.878 0.938 0.949 0.949 0.926 0.927888" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_c_us, best_scores_us, scores_table_us = printing_KFold_scores(X_train_under_sample, y_train_under_sample)\n", + "print(f'best_c_us: {best_c_us};')\n", + "print(f'best_scores_us: {best_scores_us};')\n", + "scores_table_us" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "过采样数据集作为训练集训练模型" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best_c_os: 10;\n", + "best_scores_os: 0.9451956108052839;\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
C_parameterscore-1score-2score-3score-4score-5Mean recall scores
00.0010.9430.9430.9420.9430.9410.942472
10.010.9450.9450.9440.9450.9420.944206
20.10.9460.9460.9450.9450.9430.944903
310.9460.9460.9450.9460.9430.945153
4100.9460.9460.9450.9460.9430.945196
\n", + "
" + ], + "text/plain": [ + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 0.001 0.943 0.943 0.942 0.943 0.941 0.942472\n", + "1 0.01 0.945 0.945 0.944 0.945 0.942 0.944206\n", + "2 0.1 0.946 0.946 0.945 0.945 0.943 0.944903\n", + "3 1 0.946 0.946 0.945 0.946 0.943 0.945153\n", + "4 10 0.946 0.946 0.945 0.946 0.943 0.945196" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_c_os, best_scores_os, scores_table_os = printing_KFold_scores(X_train_over_sample, y_train_over_sample)\n", + "print(f'best_c_os: {best_c_os};')\n", + "print(f'best_scores_os: {best_scores_os};')\n", + "scores_table_os" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. 应用到测试集查看效果" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import plot_confusion_matrix\n", + "import seaborn as sns" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "默认数据集训练出来的模型" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 85296\n", + " 1 0.88 0.62 0.73 147\n", + "\n", + " accuracy 1.00 85443\n", + " macro avg 0.94 0.81 0.86 85443\n", + "weighted avg 1.00 1.00 1.00 85443\n", + "\n" + ] + } + ], + "source": [ + "# 使用前面求出的最优参数 c 训练模型\n", + "lr = LogisticRegression(C=best_c, penalty='l2')\n", + "lr.fit(X_train.values, y_train.values.flatten())\n", + "\n", + "# 测试模型\n", + "y_pred = lr.predict(X_test.values) # 注意这里测试时, 使用的是原始数据\n", + "\n", + "# 计算混淆矩阵\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "\n", + "# 可视化混淆矩阵\n", + "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + "plt.title('混淆矩阵 - 原始数据的训练模型')\n", + "plt.show()\n", + "\n", + "# 生成分类指标报告\n", + "report = classification_report(y_test, y_pred)\n", + "\n", + "# 打印报告\n", + "print(report)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下采样数据集训练出来的模型" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.98 0.99 85296\n", + " 1 0.07 0.90 0.13 147\n", + "\n", + " accuracy 0.98 85443\n", + " macro avg 0.53 0.94 0.56 85443\n", + "weighted avg 1.00 0.98 0.99 85443\n", + "\n" + ] + } + ], + "source": [ + "# 使用下采样数据集和下采样数据集的最优参数 c 训练模型\n", + "lr_us = LogisticRegression(C=best_c_us, penalty='l2')\n", + "lr_us.fit(X_train_under_sample.values, y_train_under_sample.values.flatten())\n", + "\n", + "# 测试模型使用的应该是同一套测试集\n", + "y_pred_us = lr_us.predict(X_test.values)\n", + "\n", + "# 计算混淆矩阵\n", + "cm_us = confusion_matrix(y_test, y_pred_us)\n", + "\n", + "# 可视化混淆矩阵\n", + "sns.heatmap(cm_us, annot=True, fmt='d', cmap='Blues')\n", + "plt.title('混淆矩阵 - 下采样数据的训练模型')\n", + "plt.show()\n", + "\n", + "# 生成分类指标报告\n", + "report_os = classification_report(y_test, y_pred_us)\n", + "\n", + "# 打印报告\n", + "print(report_os)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "过采样数据集训练出来的模型" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.97 0.99 85296\n", + " 1 0.06 0.92 0.11 147\n", + "\n", + " accuracy 0.97 85443\n", + " macro avg 0.53 0.95 0.55 85443\n", + "weighted avg 1.00 0.97 0.99 85443\n", + "\n" + ] + } + ], + "source": [ + "# 使用下采样数据集和下采样数据集的最优参数 c 训练模型\n", + "lr_os = LogisticRegression(C=best_c_os, penalty='l2')\n", + "lr_os.fit(X_train_over_sample.values, y_train_over_sample.values.flatten())\n", + "\n", + "# 测试模型使用的应该是同一套测试集\n", + "y_pred_os = lr_os.predict(X_test.values)\n", + "\n", + "# 计算混淆矩阵\n", + "cm_os = confusion_matrix(y_test, y_pred_os)\n", + "\n", + "# 可视化混淆矩阵\n", + "sns.heatmap(cm_os, annot=True, fmt='d', cmap='Blues')\n", + "plt.title('混淆矩阵 - 过采样数据的训练模型')\n", + "plt.show()\n", + "\n", + "# 生成分类指标报告\n", + "report_os = classification_report(y_test, y_pred_os)\n", + "\n", + "# 打印报告\n", + "print(report_os)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. 查看逻辑回归的阈值对结果的影响" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "thresholds = np.arange(0.1, 1.0, 0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred_proba = lr.predict_proba(X_test.values)\n", + "\n", + "j = 1\n", + "fig = plt.figure(figsize=(20, 15))\n", + "\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall = y_pred_proba[:, 1] > i\n", + "\n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + "\n", + " cm = confusion_matrix(\n", + " y_test, y_test_predictions_high_recall)\n", + "\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + " plt.title(f'Threshold >= {i:.1f}')\n", + "\n", + "# 调整子图之间的间距\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.4)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred_proba_us = lr_us.predict_proba(X_test.values)\n", + "\n", + "j = 1\n", + "fig = plt.figure(figsize=(20, 15))\n", + "\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall_us = y_pred_proba_us[:, 1] > i\n", + "\n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + "\n", + " cm = confusion_matrix(\n", + " y_test, y_test_predictions_high_recall_us)\n", + "\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + " plt.title(f'Threshold >= {i:.1f}')\n", + "\n", + "# 调整子图之间的间距\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.4)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjcAAATBCAYAAAB36sYSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdfVhUdf7/8dcAcaOEgBQGmg6GBiVairIWEWpRKuDdb4to1/xGZma6KWxZQveQ1mJaaBqULqKuUpaVRplKrVGpawiRVK5lYRkZMuLNqMHvD9epibFAkZvj89F1rt057zlnPjPXbufFvOd8Pqa6uro6AQAAAAAAAAAAtBFOLT0AAAAAAAAAAACAxqC5AQAAAAAAAAAA2hSaGwAAAAAAAAAAoE2huQEAAAAAAAAAANoUmhsAAAAAAAAAAKBNobkBAAAAAAAAAADaFJobAAAAAAAAAACgTaG5AQAAAAAAAAAA2hSaG0ATslgsLT0EAACAs4asAwAAjIysA7QtNDfOcRs3bpTJZHK4Pfzww5Kka6+91vbfW8ptt92m2267rUnOtWjRInXr1q3JX/err75S7969VVZWdvqDa6AVK1aoR48e8vHx0fjx43XkyJHTOs+MGTOa7HMFAKA1Ius03eu2pazz8ccfa8CAAXJzc5O3t7emTJmi48ePn6XRAgDQcsg6Tfe6bSnr1NXV6cUXX1RiYqLGjh2rN9988yyNFGjdaG6c4/r27avNmzdr8+bNGj58uHr06GF7PH78+JYeXpvSrVs3Pf/887rxxhu1bdu2s/Y669atU0JCgq6//notX75c27dv17333tvo8yxbtkzp6elnYYQAALQeZJ2m01ayznfffaehQ4fK2dlZ8+fP15133qlnn31WTz755FkbMwAALYWs03TaStaRpIkTJ+rBBx9UYGCgfv75Zw0fPlw5OTlnacRA6+XS0gNAyzr//PPVr18/SVLHjh3l4eFhe4zGi4mJUV5enkaMGKFly5Zp4MCBTf4aaWlpiomJ0XPPPSdJ6t69u0JCQvTwww/L39+/QedYsGCBkpOTFRoa2uTjAwCgNSHrNK22kHWeffZZdevWTRs3bpSrq6skaffu3crPz9eMGTOafLwAALQksk7TagtZZ8uWLXrxxRdVXFysSy+9VJLk5uam+fPn6/bbb2/y8QKtGXduAE3s6quv1qpVq5SYmKj169fb9n/11VenvFXUZDJp48aNf3jumpoaffTRR0pMTLTtu+SSSxQSEmL3Wn/ko48+0rp16wg8AACg0Vp71pk4caJeeeUVW2NDOvFlz88//9zwNwkAAM5ZrT3reHp6Ki8vz9bYkKTOnTvLarU2/E0CBkFzAw324osvqlu3bvLy8tItt9xiNx/gyTkMv/32WyUkJMjPz09ff/21rX7kyBH97W9/k7+/v3x8fHTTTTepsrLS7vwzZ85Ut27d1K5dO/Xt29fhReH1119XSEiI2rdvrxtvvFE//vijrfbdd9/pz3/+szw9PeXv76/777+/0XMrL168WF27dlW7du00btw4HT16tFHHn3TllVdqzZo1Gj9+vN544w1JUkBAgLZt23bKrSGNhu+//161tbUKCwuz2x8UFKQvvviiwePLzs7WgAEDGvemAAAwOLJOw7XmrNO5c2ddfPHFtse1tbV6++23z8ovLwEAaEvIOg3XmrPOpZdeqjFjxtidc/HixRo5cmQj3iFgDExLhQZ59dVXdejQIc2ePVv79u3TXXfdpYEDB2rSpEm25/z000+66qqrFBUVpYcffli+vr622l133aV33nlHzz33nNq3b6/k5GSNGjVK77//vu38999/vzIzM9WnTx8tWbJEI0aM0N69e+Xm5ibpxG1369at05NPPilXV1fdcccdevLJJ/X000/r8OHDGjx4sJycnLR8+XLt3btXycnJ+vHHH5Wdnd2g91hUVKTbbrtNEydO1KhRo7RgwQJbp/50hISE6J133tENN9ygQ4cO6c9//rP69OlzWuc66fDhw5Ikb29vu/2enp71QsXvcXKirwkAwK+RdRqvNWedX8vNzdXOnTv16quvntHYAABoy8g6jdcWss7IkSO1fv16DRo0iOk3cU6iuYEG+fzzz/X555+rc+fOkqRVq1apuLjY7jmvv/66nnnmGU2ZMsVu/1dffaXFixfr5ZdftnWRjx8/rvj4eO3atUtms1m7du3Seeedp/Hjx6t9+/a68sorNXLkSLvpA8rKyvTxxx/bOuGFhYW2MSxfvlzl5eXasWOHgoODJZ34Av/222/XjBkz1K1btz98j3PmzNFll12mrKwsSSduQ2zIcb+nqqpKx48fl5+fn+19n4qzs7NMJtPvnu9kIHB2drbbbzKZbBdIAADQeGSd09Pas87333+vadOm6Y477mCtMQDAOY2sc3pae9YZMmSIfvzxR23YsEGbNm1SdHR0o88BtGX8fBsNMmLECNsFUJIuuOACHTt2zO45l112me655556x5aUlKiurk6jRo2yzUMYHx8vSbZb7kaPHi0fHx9dfvnluuOOO/TKK68oKipK7dq1s50nIiLC7ha/X49hy5Yt6tKli+0CKJ34F3xdXZ22bNnSoPf4+eefq3///rbHbm5uZzR108aNGzVmzBgtW7ZMgwYN0ldffaXzzjvvlFthYeEfnvPCCy+UJH377bd2+/ft26f27duf9lgBADjXkXUar7Vnnbq6Oo0bN04+Pj56+umnG3UsAABGQ9ZpvNaedSTp7rvv1vvvv6/o6GiNHz++0ccDbR13bqBBunfv/ofP6dev3+9Od/TWW2/J39/fbl9QUJAk6eKLL9bnn3+ut956S//+97/14IMP6rHHHtMnn3wiLy+vPxxDXV3dadV+rba2tl7n/LePG2rVqlVKTk7WG2+8YfuV4Mm5GU/lkksu+cPzent76+KLL9a///1v2wW7rq5O//nPfxQVFXVaYwUAAGSdxmoLWefRRx+1/YrR09OzUccCAGA0ZJ3Gac1Zp6amRjU1NerUqZNtX1xcnF599VUdP35cLi583YtzB3duoEFO92Ignej8S5LValWfPn3Up08f+fv76+mnn7YtTpWdna2NGzfqpptu0rPPPqvCwkLt2rVL7777boPGEB4erm+++UY7d+607Vu/fr1MJlODFnSSTlyEfv1rgGPHjunjjz9u1HuVpJycHE2fPl3vvvuu3fQHrq6utvfvaGvoH91jxozRvHnzZLFYJEn/+te/tHfvXg0ZMqTRYwUAACeQdRquLWSdpUuX6pFHHtHcuXPVt2/fxr1BAAAMiKzTcK0962RmZiomJsZuiqwvvvhCnTt3prGBcw7/i8dZFxQUpL/85S+6++67deDAAQUEBCgjI0Offvqp5s+fL0nau3evHnnkEVmtVnXu3FkrV66UJJnN5ga9xs0336xZs2Zp5MiRSk9P1w8//KDk5GSNGzeuwee4++67NWjQIN17772KjY3Viy++qIqKika911mzZmnp0qXauHGjXQe9Kd13331atmyZwsPD1b9/f61YsUJxcXG2P9wPHDig8vJyXXbZZfLw8DgrYwAAAL8g6zStM806X3zxhZKSknTNNdfoyiuvtPuSo6FfjgAAgF+QdZrWmWad2267TbNnz9aYMWN0zz336IsvvtCcOXP02GOPnZXxAq0Zd26gWTz//PMaOXKk7r33XsXFxcnZ2Vnr1q3T+eefL0n6+9//rsTERP3973/XoEGD9Oabbyo7O1t9+vRp0Pk9PDy0fv169ezZUzfddJPuv/9+jR8/XgsWLGjwGKOjo5Wbm6s1a9Zo+PDhOnLkiEaPHt3g43fu3Kk1a9ac1QugdGJ+xi1btmjAgAEqLS3Vvffeq+XLl9vqW7duVXh4uMrLy8/aGAAAgD2yTtM506zzxhtv6PDhwyosLFR4eLjdBgAATg9Zp+mcada5+OKLVVBQoJ9++knx8fHKzMzUU089palTp561MQOtlamuoRPXAQAAAAAAAAAAtALcuQEAAAAAAAAAANoUmhsAAAAAAAAAAKBNobkBAAAAAAAAAADaFJobAAAAAAAAAACgTaG5AQAAAAAAAAAA2hSaGwAAAAAAAAAAoE2huQEAAAAAAAAAACRJ2dnZ6tKli9q1a6drr71W//3vfyVJpaWlCg8Pl4+Pj1JSUlRXV2c7prCwUCEhIfLz81NmZqbd+fLz89W1a1cFBARo2bJldrWsrCz5+/srKChI69evb9Q4TXW/HkEL8LhiUku+PGCzIf/xlh4CIEmK6O7dpOdrin/PHt72XBOMBDg3kXXQWnyxPvOPnwQ0g84+rk16PrIO0LLIOmgtvv33My09BECS1LG9S5Ofsznzzs6dOxUdHa1XX31Vfn5+euSRR/TFF1/onXfe0aWXXqqYmBilpKRo8uTJGjNmjMaNG6fKykpdcsklmjZtmhISEnTzzTfr6aefVnR0tEpLS9W3b19lZWVpwIABGjVqlN544w317NlTBQUFGjFihJYvX64LLrhAt956qzZv3qyOHTs2aKzcuQEAAAAAAAAAALRt2zZFREToyiuv1MUXX6z/+7//05dffqm1a9equrpamZmZ6t69u9LT05WTkyNJysvLU0BAgFJTUxUcHKy0tDRbLTs7W9HR0UpKSlKvXr00adIk5ebmSpLmz5+vsWPHKj4+XgMHDlR8fLxWrVrV4LHS3AAAozM5nfkGAADQWpF1AACA0TVB3rFarbJYLHab1Wqt91KhoaFav369PvnkE1VXV2vevHm67rrrVFxcrIiICLVr106SFBYWprKyMklScXGxoqOjZTKZJEn9+/fX1q1bbbVBgwbZzt/QWkOQ4gDA6EymM98AAABaK7IOAAAwuibIOxkZGerQoYPdlpGRUe+lQkNDNWbMGF1xxRXy9vZWUVGRnn76aVksFpnN5l8NySRnZ2dVVVXVq3l5eWnPnj2SdNq1hqC5AQBGx68ZAQCAkZF1AACA0TVB3pk+fbqqq6vttunTp9d7qY8//livv/66PvzwQ+3fv18JCQkaOnSoXFxc5ObmZvdcd3d3HTp0qF7t5H5Jp11rCFIcAAAAAAAAAAAG5ubmJi8vL7vtt80KSVq2bJluvvlmDRgwQB06dNDjjz+unTt3ytfXV5WVlXbPPXDggFxdXevVTu6XdNq1hqC5AQBGx1QNAADAyMg6AADA6Jox79TW1uqHH36wPT5w4IDt7oyioiLb/l27dslqtcrX11fh4eF2tW3btikwMFCSTrvWEDQ3AMDomKoBAAAYGVkHAAAYXTPmncjISL3yyiuaPXu2li5dqhEjRqhTp06aPHmyLBaLXnrpJUlSenq6hgwZImdnZ8XFxWnTpk1at26djh07plmzZikmJkaSNHr0aC1fvlwlJSWqqanR3LlzbbUxY8Zo3rx5qqio0N69e5WTk2OrNYRLIz5CAEBbxK8RAQCAkZF1AACA0TVj3hk9erQ+++wzPfPMM/ruu+90+eWXa9WqVTrvvPOUnZ2thIQEpaSkyMnJSRs3bpQk+fn5afbs2Ro6dKg8PT3l7e2tRYsWSZJ69+6tKVOmqF+/fnJ3d1dwcLAmTpwoSYqNjdXKlSsVHBwsSRo8eLBGjRrV4LHS3AAAAAAAAAAAADKZTEpNTVVqamq9WlxcnHbu3KmtW7cqIiJCHTt2tNUmTJigmJgY7dixQ5GRkfL09LTVnnjiCSUmJqqiokJRUVG2dTVMJpNyc3M1efJkHTx4UFFRUTI1opFDcwMAjI6pFgAAgJGRdQAAgNG1orzTqVMnDRs2zGHNbDbLbDY7rIWGhio0NNRhLTw8/LTGQnMDAIyOqRoAAICRkXUAAIDRkXccorkBAEbXirr7AAAATY6sAwAAjI684xCfCgAAAAAAAAAAaFO4cwMAjI5bFwEAgJGRdQAAgNGRdxyiuQEARsetiwAAwMjIOgAAwOjIOw7R3AAAo6O7DwAAjIysAwAAjI684xAtHwAAAAAAAAAA0KZw5wYAGB23LgIAACMj6wAAAKMj7zhEcwMAjI4LIAAAMDKyDgAAMDryjkM0NwDA6JyYlxEAABgYWQcAABgdecchWj4AAAAAAAAAAKBN4c4NADA6bl0EAABGRtYBAABGR95xiOYGABidiVsXAQCAgZF1AACA0ZF3HKK5AQBGR3cfAAAYGVkHAAAYHXnHIZobAGB0dPcBAICRkXUAAIDRkXccouUDAAAAAAAAAADaFO7cAACj49ZFAABgZGQdAABgdOQdh2huAIDRcesiAAAwMrIOAAAwOvKOQ7R8AMDoTE5nvgEAALRWzZx1Fi1aJJPJVG9btGiRCgsLFRISIj8/P2VmZtodl5+fr65duyogIEDLli2zq2VlZcnf319BQUFav369Xe3BBx+Uj4+PwsLCtH379tP7jAAAQNvGdzsOGfNdAQAAAABwFtxyyy2qqqqybd988438/PwUEhKiuLg4JSQkqKioSHl5edqwYYMkqbS0VImJiUpNTVVBQYHS0tJUXl4uSSooKFBycrIWLlyoJUuWKCkpSfv27ZMkLViwQAsWLNDq1av1+OOP6+abb9bRo0db7L0DAAC0JjQ3AMDoTKYz3wAAAFqrZs46rq6u8vb2tm3//Oc/NXLkSBUVFSkgIECpqakKDg5WWlqacnJyJEnZ2dmKjo5WUlKSevXqpUmTJik3N1eSNH/+fI0dO1bx8fEaOHCg4uPjtWrVKlstOTlZkZGRiouLU8+ePfXee+817ecHAABaP77bcYjmBgAYHbcuAgAAI2uCrGO1WmWxWOw2q9X6hy995MgRzZkzRw888ICKi4sVHR0t0/++POjfv7+2bt0qSSouLtagQYNsxzWkVldXp5KSklMeBwAAziF8t+OQMd8VAOAXdPcBAICRNUHWycjIUIcOHey2jIyMP3zppUuXasCAAerWrZssFovMZrOt5uXlpT179kjSadVqampUW1t7yuMAAMA5hO92HHJp6QEAAAAAANCSpk+frqlTp9rtc3Nz+8Pjnn/+eT388MOSJBcXF7tj3N3ddejQodOuubi41BvHr48DAAA419HcAACjM+ithwAAAJKaJOu4ubk1qJnxa19++aW+/PJLXXfddZIkX19fVVZW2uoHDhyQq6vradc8PDzk4eGhyspKeXl51TsOAACcQ/huxyE+FQAwOuZlBAAARtZCWWfFihUaPny4zjvvPElSeHi4ioqKbPVt27YpMDDwjGr9+vU7ZQ0AAJxD+G7HIWO+KwDAL5iXEQAAGFkLZZ233npL1157re1xXFycNm3apHXr1unYsWOaNWuWYmJiJEmjR4/W8uXLVVJSopqaGs2dO9dWGzNmjObNm6eKigrt3btXOTk5drWZM2fKYrHo888/V35+vq0GAADOIXy34xDNDQDAWXPfffcpNjbW9ri0tFTh4eHy8fFRSkqK6urqbLXCwkKFhITIz89PmZmZdufJz89X165dFRAQoGXLltnVsrKy5O/vr6CgIK1fv/7sviEAAABJhw8f1kcffaSBAwfa9vn5+Wn27NkaOnSo/P39VV5erhkzZkiSevfurSlTpqhfv34KDAyUs7OzJk6cKEmKjY3V4MGDFRwcLLPZrCuuuEKjRo2SJN1555268MIL1blzZ/Xq1Uu33Xab+vbt2/xvGAAAoBVizQ0AMLoWuvVw+/btmjdvnoqLiyVJVqtVsbGxiomJ0fLlyzV58mQtWrRI48aNU2VlpeLi4jRt2jQlJCTo5ptv1hVXXKHo6GiVlpYqMTFRWVlZGjBggEaNGqUrr7xSPXv2VEFBgZKTk7V8+XJdcMEFuvXWW7V582Z17NixRd4zAABoAS2QdTw8PGS1WuvtnzBhgmJiYrRjxw5FRkbK09PTVnviiSeUmJioiooKRUVF2dbOMJlMys3N1eTJk3Xw4EFFRUXJ9L9fV7q5uemdd97Rpk2b5Obmpv79+zfPGwQAAK2LQaeVOlM0NwDA6Frg1sPa2lqNHz9e9957r4KCgiRJa9euVXV1tTIzM9WuXTulp6fr7rvv1rhx45SXl6eAgAClpqbKZDIpLS1NOTk5io6OVnZ2tqKjo5WUlCRJmjRpknJzc/X4449r/vz5Gjt2rOLj4yVJ8fHxWrVqle25AADgHNDKplkwm80ym80Oa6GhoQoNDXVYCw8Pd7jfyclJkZGRTTY+AADQBrWyvNNa0PIBAKNrgUWnnn/+eZWUlKhbt25avXq1jh49quLiYkVERKhdu3aSpLCwMJWVlUmSiouLFR0dbfuVYv/+/bV161ZbbdCgQbZzN7QGAADOESywCQAAjK4Z886iRYtkMpnqbYsWLTorU4o/+OCD8vHxUVhYmLZv396oj4UUBwD4Q1arVRaLxW5zNBWDJNXU1Oihhx5SUFCQvv76a82ePVtXX321LBaL3a8YTSaTnJ2dVVVVVa/m5eWlPXv2SNJp1wAAAAAAANA4t9xyi6qqqmzbN998Iz8/P4WEhCguLk4JCQkqKipSXl6eNmzYIEm2KcVTU1NVUFCgtLQ0lZeXS5JtSvGFCxdqyZIlSkpK0r59+yRJCxYs0IIFC7R69Wo9/vjjuvnmm3X06NEGj5XmBgAYncl0xltGRoY6dOhgt2VkZDh8uVdeeUUHDx7Uhg0b9Mgjj+idd97RgQMH9OKLL8rNzc3uue7u7jp06JBcXFzsaif3SzrtGgAAOEc0QdYBAABo1Zox77i6usrb29u2/fOf/9TIkSNVVFRkm1I8ODjYNqW4JLspxXv16mWbUlyS3ZTiAwcOtE0pfrKWnJysyMhIxcXFqWfPnnrvvfcaPFaaGwBgcI5uJWzsNn36dFVXV9tt06dPd/h63377rSIiIuTn5yfpRAMiLCxM+/fvV2Vlpd1zDxw4IFdXV/n6+trVTu6XdNo1AABwbmiKrAMAANCaNUXeacysHCcdOXJEc+bM0QMPPNDkU4rX1dWppKTkjKYbp7kBAAbXFBdANzc3eXl52W2/vQvjpM6dO+vw4cN2+77++ms988wzKioqsu3btWuXrFarfH19FR4eblfbtm2bAgMDJem0awAA4NxAcwMAABhdU+SdxszKcdLSpUs1YMAAdevWrcmnFK+pqVFtbe0ZTTdOcwMA0KSGDRumsrIyPf/88/r22281d+5cFRcXa9SoUbJYLHrppZckSenp6RoyZIicnZ0VFxenTZs2ad26dTp27JhmzZqlmJgYSdLo0aO1fPlylZSUqKamRnPnzrXVxowZo3nz5qmiokJ79+5VTk6OrQYAAAAAAIATGjMrx0nPP/+8JkyYIOn0pw0/Vc3FxUWSzmi6cZcGPxMA0DY1848RO3bsqDVr1ig5OVlTp07VRRddpBUrVqhLly7Kzs5WQkKCUlJS5OTkpI0bN0qS/Pz8NHv2bA0dOlSenp7y9vbWokWLJEm9e/fWlClT1K9fP7m7uys4OFgTJ06UJMXGxmrlypUKDg6WJA0ePFijRo1q3jcMAABaFjdeAAAAo2uCvOPm5nbKWTgc+fLLL/Xll1/quuuuk3T604afqubh4SEPDw9VVlbKy8ur3nENQXMDAAyuJaZauOqqq+ymizopLi5OO3fu1NatWxUREaGOHTvaahMmTFBMTIx27NihyMhIeXp62mpPPPGEEhMTVVFRoaioKNuFzmQyKTc3V5MnT9bBgwcVFRXF1BIAAJxjuPYDAACja4m8s2LFCg0fPlznnXeepBNTgy9dutRWdzRt+O23337K2uDBg+vV+vXrp6KiInXv3t1W69mzZ4PHyLRUAGBwrW0e6k6dOmnYsGF2jY2TzGazbrzxRrvGxkmhoaG67rrrHHbww8PDde211/LlBgAA56DWlnUAAACaWkvknbfeekvXXnut7fHZmFJ8zJgxmjlzpiwWiz7//HPl5+c3arpxmhsAAAAAAAAAAECSdPjwYX300UcaOHCgbd+vpxT39/dXeXm5ZsyYIcl+SvHAwEA5OzvbTSk+ePBgBQcHy2w264orrrBNKX7nnXfqwgsvVOfOndWrVy/ddttt6tu3b4PHybRUAGBw/BoRAAAYGVkHAAAYXXPnHQ8PD1mt1nr7m3pKcTc3N73zzjvatGmT3Nzc1L9//0aNk+YGABgcf/ADAAAjI+sAAACja015x2w2y2w2O6yFhoYqNDTUYS08PNzhficnJ0VGRp7WWGhuAIDRtZ7rHwAAQNMj6wAAAKMj7zjEmhsAAAAAAAAAAKBN4c4NADC41nTrIgAAQFMj6wAAAKMj7zhGcwMADI4LIAAAMDKyDgAAMDryjmM0NwDA4LgAAgAAIyPrAAAAoyPvOMaaGwAAAAAAAAAAoE3hzg0AMDi6+wAAwMjIOgAAwOjIO47R3AAAo+P6BwAAjIysAwAAjI684xDNDQAwOLr7AADAyMg6AADA6Mg7jrHmBgAAAAAAAAAAaFO4cwMADI7uPgAAMDKyDgAAMDryjmM0NwDA4LgAAgAAIyPrAAAAoyPvOEZzAwCMjusfAAAwMrIOAAAwOvKOQ6y5AQAAAAAAAAAA2hTu3AAAg+PWRQAAYGRkHQAAYHTkHcdobgCAwXEBBAAARkbWAQAARkfecYzmBgAYHBdAAABgZGQdAABgdOQdx1hzAwAAAAAAAAAAtCncuQEABkd3HwAAGBlZBwAAGB15xzGaGwBgdFz/AACAkZF1AACA0ZF3HGJaKgAwOJPJdMYbAABAa9WSWee+++5TbGys7XFpaanCw8Pl4+OjlJQU1dXV2WqFhYUKCQmRn5+fMjMz7c6Tn5+vrl27KiAgQMuWLbOrZWVlyd/fX0FBQVq/fv1pjxUAALRdfLfjGM0NAAAAAAAaafv27Zo3b57mzJkjSbJarYqNjVXfvn21ZcsWlZWVadGiRZKkyspKxcXFKSEhQUVFRcrLy9OGDRsknWiIJCYmKjU1VQUFBUpLS1N5ebkkqaCgQMnJyVq4cKGWLFmipKQk7du3r0XeLwAAQGtDcwMADI7uPgAAMLKWyDq1tbUaP3687r33XgUFBUmS1q5dq+rqamVmZqp79+5KT09XTk6OJCkvL08BAQFKTU1VcHCw0tLSbLXs7GxFR0crKSlJvXr10qRJk5SbmytJmj9/vsaOHav4+HgNHDhQ8fHxWrVqVRN9cgAAoK3gux3HaG4AgMFxAQQAAEbWFFnHarXKYrHYbVar9ZSv+fzzz6ukpETdunXT6tWrdfToURUXFysiIkLt2rWTJIWFhamsrEySVFxcrOjoaFuu6t+/v7Zu3WqrDRo0yHbuhtYAAMC5g+92HKO5AQBGZ2qCDQAAoLVqgqyTkZGhDh062G0ZGRkOX66mpkYPPfSQgoKC9PXXX2v27Nm6+uqrZbFYZDabfxmWySRnZ2dVVVXVq3l5eWnPnj2SdNo1AABwDuG7HYdcWnoAAAAAAAC0pOnTp2vq1Kl2+9zc3Bw+95VXXtHBgwe1YcMG+fn56fjx4+rVq5defPFFjRs3zu657u7uOnTokFxcXOzOd3K/pNOuAQAAnOtobrQij0+O16VBnTTmbwskSbeN/JMeHD9Uvh3aa8unX+vOh5foq4oTi8f94+9jNDHhWtuxO3dX6vL4RyRJf4mL0JS/DFKgv7fe3lSmqTNXat/+g7o1doBeePQv9V73jrRcLXn9o7P/BtEmHKjer4f/dpvuf3KeLvAPsKv968XntGf3Lt378D/qHeeo9t7br+utVUtV9eMP6tXvT/rLhGSd38H7D2toWka99RBA23GqDPL1nn3qGtCx3v7rk+bo/a1f2B538PTQtldm6Nqx/9Du736Su9t5ynnsLxrypxBZjx1X3usf64FnXlVdXZ3tmJFD+ujOP1+jG8bPPTtvCm3eW2+8qqceT623P2XGY6r84Xu9unKZjhw5rCv6DlDKjEfVwdvH9pyKb3br7tsT9Orbm+yOnZF8j4r+vdH2+Mp+A/TUc9ln7T3ghKbIOm5ubqdsZvzWt99+q4iICPn5+Uk60YAICwvTjh07VFlZaffcAwcOyNXVVb6+vna1k/slnXYNAIDGuPfu8RoSc6OGxY207Uu9b5p8fH019b4HbftefXmFchZkaf/+/eoV1kePZjwtvwsusNW/3f21bv/rzSrYWNSs4z/X8d2OY0xL1UpcHhyg8X+OVPJT+ZIkc2c/PXDHjfp/9y5Qn1GP6b/fVtp9KXBl6MUacc88dYpMUafIFEUkPClJih7QU//4+xj9/elX1P/PGTq/vbv+9Y87JEn/WrvF9vxOkSm6JGaGKqsOaNO2nc3/htEqHajer9kPT9WPe7+rV9u96wutf/NlJd45tUG1T7d9rLwFmbrljr/p8aw8HTl0UHMf//sf1tD0mJcRQEs7VQYZec98u/39b8rQDz8dUHH5N3bHp987Qhdd0MH2+N6xg3XseK2uGPW4Rk6arxGDe+svcQNs9SF/CtELj/6Ff3/hdw2OGabX3tlk25avfkcdvH10UUCgNq4r0DPPL9LCf+artvZnzZ/zlO24PRXfaPrUiTpgsdQ75+c7PlV23iu2cz76FM215tDcWadz5846fPiw3b6vv/5azzzzjIqKfvmiZ9euXbJarfL19VV4eLhdbdu2bQoMDJSk064BaD1uG/knfbH2Me37IFMFL0xRt8ATP94I7X6R/r0kRXsKZyn9byMcHpv75Dhl3vf/bI8fvHOoDm97rt4W2TdYkvTxv6bb7Z+XdstZf39o+wrWvKGPiux/lPHBv9/Tf7Zu1h0T77HtK962VS/Mf05pjz2pl18vUF1dnZ575pccVPHtN5o2+S6HOQhnF9/tOEZzoxUwmUzKmpGgZ/M22O7M6HNpZ31c8pU+2fGtvvm+Sv989UN173KiS+rs7KSQoIv0761fqrrmsKprDqvm0InF7hKH99eS1z/S+o926Jvvq/TAM6/qqisvkY9XOx07/rPt+dU1h3XL8P5avX67dn37Y4u9d7Qu82bOUMS1MfX219bWatHcDMWMuFkXXhTYoNq/312jq4cM0+VXDlDHCzvpptvv0eefFqvmQPXv1tD0uAACaGmnyiCf/fd7u/13/vkaPZe3QZaaI7Zjr7qyu4ZF9dKPVTW2ff0u66Zlaz7WnspqbS3brfUfldtyUlAXP82+//9pwb/ea/b3ibblvPPOk+f5Xrbt7TWv6+qoQSr/7FP1/1OkunQ1K7DLxRp0/VBVfLvbdtyM5Hs0fMSYeuer/GGv6urqZO4ebDunh0e75nxL56zmzjrDhg1TWVmZnn/+eX377beaO3euiouLNWrUKFksFr300kuSpPT0dA0ZMkTOzs6Ki4vTpk2btG7dOh07dkyzZs1STMyJ3D169GgtX75cJSUlqqmp0dy5c221MWPGaN68eaqoqNDevXuVk5NjqwFoHU7141TX81z08pw79Z/PvtFVibN0aVAn/SUuwu7YmKtDFdkvWI9kvWHb9/RLb5/yxx8e7ucpqIufugy631afOnNlc79ltDGW6v16dvYsXdztlzWcDh8+pKczHtNdk/6m88/3su3/Zvdu/f3BhxQ+4E+60L+ThsWN1Oc7PrPV//63uxU/6v8JzY/vdhyjudEK3DHmal0WHKCv9+zTsKheOs/FWZ/993tFhfdQWI9AeXm6a/yfI/XuhzskSZdfEiAnJ5M+Wj5dPxVl6rXnJqpLpxO3yXf09tQ33/1kO/fPP9ee+M/aWrvXdHN10d23XKtZOQXN9C7RFvzf5Ad0ffxN9fZvWPOKvvlqp/z8L9J/PnxPx48d+8NajWW/Ol7gb3uek5Oz7T9/rwYAMLZTZZCLLuiguEFhmrdso22f63kueu7BBCXPytfBw1bb/s92fqdxIwaqg6eHQoI66cbIy2056af9B3V14lP67L/fN8v7gTEctVr1yr+W6Jaxd6irubs2Fb6rPRXfqOqnfVr7+ir17f8n23Of+Mdzuib6unrnKC8rVW1trW6KHaxh1/bXYzNSdMDCDzeMqGPHjlqzZo0WL16sHj16aM6cOVqxYoW6dOmi7OxsTZo0SX5+fnrttdc0c+ZMSZKfn59mz56toUOHyt/fX+Xl5ZoxY4YkqXfv3poyZYr69eunwMBAOTs7a+LEiZKk2NhYDR48WMHBwTKbzbriiis0atSoFnvvAOo71Y9TY64KlZenh+77x8va9e2Peui513XbiF+uJ+3cXTVn+k1Ke3a1qmt+uRvMevT4KX/80adnF5V+sUc/VtXY6kesxxwNC7CZm/mUoqKH6PJeYbZ9Ly6Yp+PHjsnZxVkff/iBav/3veHw+JGKih5se97ur3ep88VdbY+fmjNP0UOub77BA3/gtJsb1dXV+u6777Rv3z67+Y3ROO09XDXjrqHa9e0+XXyRr+5JjNb6l+7VVxX7tOrdT/TRv6Zr7/tPa0CYWdNnr5IkhQR10udf/6DbU/+p8JsydPznWj03I0GS9Mln3+jGay63deP+EhehLaVf2f0CUpJuurGfNpd+rd2/aoQAF3QKqLfvyOFDWrXkBV3YKVA//vC9Cl5dpsdTxuuo9cjv1rp2v1SffLzJdoF8/503ZO4RqnbtPX+3hqZHdx84PWSds+NUGSRpzNVa+dZWHTx81Lbv77dfry92/6D8t/9j99ynX3pb/cPM+v79p/Sfl2fotXc/0XtbTqzRsf/AYbsvCICGePftNQq5LEydAgI1YGCkAjp30V9GD9WYodfq8OFDSvjL7bbnXhTQ2eE5dn+9S0GX9FB65jw9m71E3++pUPb8Oc31Fs5pLZF1rrrqKhUVFenQoUPauXOnYmNjJUlxcXHauXOnFi9erM8++0yhoaG2YyZMmKDy8nLl5eVp+/bt8vf/5cc+TzzxhLZt26b8/Hx98MEH8vDwsL233NxcFRYWas2aNVq9ejXZDE2GrNM0TvXj1F49AvVxyVc6fORE86Hk8wpdGtTJdtyDd94o1/NcdPznWg0acKnD/2//9scf/S7vqsALvbV7fYa+e2+W5jxwk1zPYzldnNrWzR9p6+YPNXHKNNu+7/bs0YplS3RRYKAqvv1W8+Zm6v6p99i+oznJUr1fr728UiPH/PIj2IBAxzkIZ19Lfbdz33332XKOJJWWlio8PFw+Pj5KSUmxu34UFhYqJCREfn5+yszMtDtPfn6+unbtqoCAAC1btsyulpWVJX9/fwUFBWn9+vWNGl+j/g24ePFiZWdnq6ysTC4uLnJzc9OBAwd09OhRDRkyRDNnztSll156yuOtVqusVqvdvrran2U6h3+tHT+4j9q7u+mG8Y9r3/6DcnZ20pYVD2jizVEads3luuYvT6n8q72aOvY6vfrsXbr61qe0fO0WLV+7xXaOv2X8S5+98YjOb++uZ/75riL7XqKiZffpiPWYBoSZ9X8zFtd73TvGXK3HF6xpzreKNmrLBxtltR7W/U/O0/kdvPXzz8f14MREbVq/Vue5up2yduPoRJWX/kcPTf6rznN1084dpRo/7SFJ+t0azgL+/gUajKxz9jnKIE5OJo0bOVBDJzxr29fT7K+kMVfrTwkz653joYnDVfTJTv0tY4W8vdrppSfG6q6bozR/eeFZHz+M6fVVKzQ26S5JUuH6t7X3++/04rLX1MHbWwufy1TGw9P18JOzf/cct4xN0i1jk2yP77xnqh66/17de1/aWR071OqyTqdOnTRs2DCHNbPZLLPZ7LAWGhpq1wz5tfDw8CYbH85tZJ2mt+O/39t+nCpJu779Udf89Wklj7vONvX4ST/X1sr7fA95ebrr7luu1X/Kdssc6KdJt0Sr4of9+vO9C+2+KPztjz+Cu/nrg0926vHn18j7fA+99MRtmnxrtJ5+6Z3me8NoM6xWq2Y98YiSp6epffv2tv1r33hVvh07au7zL8rNzU0Jf7lNo4YN0eaPijTgT1fZnvf0k4/r8t599KerIlti+PitFsg727dv17x581RcXCzpxP+mYmNjFRMTo+XLl2vy5MlatGiRxo0bp8rKSsXFxWnatGlKSEjQzTffrCuuuELR0dEqLS1VYmKisrKyNGDAAI0aNUpXXnmlevbsqYKCAiUnJ2v58uW64IILdOutt2rz5s3q2LFjg8bY4Ds37rvvPuXn5ysrK0v79u3T3r17tXv3blVVVam0tFQXXnihrr32WlVVVZ3yHBkZGerQoYPddnzv1oYOwZACL/TWxyW7tG//QUknppEq/aJCnfy8tLJgqzaXfi1LzRE9nPW6zJ39FNaj/uJxP/x0QM7OTurk56XqmsMacvszuiUlW9s/r9CO/36vf/2qESKdmIs6qMsFtukbgN9T9eMP6t7zcp3fwVuS5Ozsoi7dLtEPe7793Vp7z/P14FMLNemBDF1sDtZFXbrpT/9bz+P3amh63LkBNAxZ5+w7VQaJCu+hn6oPasevppLKmpGgR7Le0HeV9af1uWlouNIXvqXKqhp98fUPejL7LY391TQPQGNUfLNbe77dbZt66t2CNxU36s/qag6St4+vJt57n97fuE41Bxq3cKa3j68s1ft19OjRP34yzghZB2gYss7Z0e+yrrYfp/pHJmvFW1v16rN36fjxWh09dtzuuVbrcbVzd1Vi7AD9sO+AbrzzWT2xYI2uT3pGA/sEadCAnrbnnvzxxwv5/7btm/zEco2dvkhffP2DNpd+rfQX1mrEkCua7b2ibXnphecVctnluioyym7/D3v3ql//P8nNzU2S1L59e3W5uKu+/eaXNcbWvP6q/rPlYz340GPNOmacWnPnndraWo0fP1733nuvgoKCJElr165VdXW1MjMz1b17d6WnpysnJ0eSlJeXp4CAAKWmpio4OFhpaWm2WnZ2tqKjo5WUlKRevXpp0qRJys3NlSTNnz9fY8eOVXx8vAYOHKj4+HitWrWqweNscHMjOztbc+fOVVhYWL2a2WzWCy+8oJ9//lkffvjhKc8xffp0VVdX220u/n0bPFgjqvhhvzzcXe32XXyRr+65dZAu8Dnftu/89u5q5+4qZ2cnpf9thG66oZ+tNiDMrJ9/rtW3e38JIN9VVit+UG+lPbtatbX2t5eOvu5KrX2/VMeP299uBjji43ehjh61/2XOvh++k0/HC363dpK37wXa8sFG/b+xE+XkbP9rnt+rAUBzI+ucfafKIKOvu1KvrS+2Pb74Ih9ddeUlSr93hL57b5a+e2+WunTy0eYV03XTDf3kZDLpAt9fpjL07+glZyeWksPp2fhugSKuipKLy3mSpLraWu2v+mXatKp9P0qqv4bdbz32YLJKPvllCrWy0mL5+HaUq6vr7xwFAM2HrHN2/PmGvg5/nFplOSg/b/uplz3bu+no8Z8VeKGP1n9ULuvRE82PmkNW7dxdqe5dfvlb2tGPP36r8qcDCrigw9l5Y2jz3nnrTb2/cb2uvyZC118TobfXvqmnn3xcr7/6sqzWX6avr62t1Q979+qCC09Ml/hZWakyZ6Xr0Yyn5dvRr6WGj7PAarXKYrHYbb+9G++k559/XiUlJerWrZtWr16to0ePqri4WBEREWrXrp0kKSwsTGVlZZKk4uJiRUdH25oo/fv319atW221QYMG2c7d0FpDNPivwO7du+vpp5/WkSNHHNYXL16sw4cPq2/fU1/U3Nzc5OXlZbedy7cuStJb73+qS82dlDTmagVe6K2JCVHq1SNQ/zdjseIH99Y9idG66YZ+WpF5h/bus6jkiwpt/7xCD909XNf276HBEZfq2QdvVt4bH9vmcZSkiTdH6fOv9ur1jdvrveb1V4Xa5qUG/kif8Ku0Z/curX/zFf304169/dq/tHvXl+p7VfTv1k5a9/oKXdS5q/oOjKp37t+roenwa0agYcg6Z9+pMsj1A0Ps9lf8UK2eQ9M04KYnbdt3ldUaec98vVG4XZu27dTjk+N18439NDEhSmkTh+vNwpLmfCswkM0f/lu9r/xlyp9effrqjVfz9forK1Tw5mt6PPXvuqxXH3X4352qp2LuHqz5c2ap5JP/6N+F7yp73hzFjbrpd49B0yDrAA1D1jk7nJxMDn+cevznWg0I+2Uauq4BHeV2not+qj6oih+q5OF+nq1mMpkU6O+tPZX7bft+++MPSdq4eJo6+3vbHg8IM+sb1lLFKczP+aeWrHxNi5e/rMXLX9bVUdG6Y8IkZb2wWP8u3KgN776tH/Z+r/nPztbx48cVPiBCP/20T3//291KHPt/ujT0Mh06dFCHDh1s6bcCNU3ecXT3XUZGRr3Xqqmp0UMPPaSgoCB9/fXXmj17tq6++mpZLBa76TVNJpOcnZ1VVVVVr+bl5aU9e/ZI0mnXGqLBa268+OKLiouL07/+9S9FRETIbDbLzc1NlZWV+uCDD3TgwAEtW7ZMF154YYNfHNJP1Qc18p75ypg6UjOnjtL3P1br1vte1Jr3StU1oKMmJUark5+XPv3yO9009QUdP16r5Ws2K7T7RVr2dJJ+/rlOy9d8rLRnX7ed0/t8D9079jrF351V7/Xc3c5T+OVddfdjy+rVAEc8vTpo6iOztTxnrpZlP6MOPn66e/oT6njBiY7+79UOHrDozfxcJT9WfzHN36uhaTX33+uTJ0/Ws8/+Mm9+9+7d9eWXX6q0tFTjxo3Tl19+qaSkJM2aNcv2ZUJhYaEmTJigyspKPfDAA5o6dart+Pz8fE2bNk3Hjh3TP/7xDyUkJNhqWVlZevTRR9W+fXtlZ2fbdfuBxiLrnF2nyiDmzn666IIO2lL6lW3fzz/X1ltw/PjPtfp2734dPHxUk59YrmceuEn/uO//yfU8F7389n/0ZPZbzfE2YDDWI0e049MSTb3/l7W/Rvy/W/TD3u+V+9ICWfZXKfTy3kpJ/eMpGW7+6//pu+8qdP+9E9SuXXvFjb5JiWPvOJvDx//QmwAahqxzdmzatlMvPPoXfbIjWj/sO6DbRv5Je/dZlLVso6bedp3+Eheh3NUf6u+3X6/1H5WrtrZOr7yzTZvy/q4Rg/toc8lXuuvmKLm4OGv9h+W2814/MER3PLTE7rXKdn6nZ2ckKH3BGvUwd9KUvwzW355c0dxvGW3Ehf6d7B63a9dOHby91efKvnokY5ZemPesdu/+Wp27XKyZmc/Kw6OdVq96Wft+/FEvzHtWL8z75e/6D/7zaXMPH7/RFHln+vTpdt+3SLJNT/Zrr7zyig4ePKgNGzbIz89Px48fV69evfTiiy9q3Lhxds91d3fXoUOHbOs4/Xa/pNOuNYSp7tcrFf2Bo0ePas2aNdq+fbssFotcXFzk6+ur8PBwXXPNNXI+jWllPK6Y1OhjgLNhQ/7jLT0EQJIU0d27Sc8XnHLmX/h98dQNDX7uwIEDNWPGDA0cOFCS5OzsLFdXV1166aWKiYlRSkqKJk+erDFjxtgWnbrkkkvsFp16+umnbYtO9e3b127RqTfeeMO26NSIESNOe9EpwBGyDozsi/WZLT0EQJLU2adpp+pq7qwDtGVknbPj/jtu0LiRA20/Tr3rkTwVl3+rYVG9tDjjNh0+cky1dXWKuWOObZqpYVG9lDZxmIIvvlA7v/lRkx5fpo+275J04scf21elqtM1KbbFxCWpg6eHFj5yq4b8KUSVVQf0j0Xv6IWV/3Y4pnPRt/9+pqWHAEiSOrZv8P0EDdaceSc9PV3r1q3T+vXrbftuuukmrVixQrfeeqttvQxJ8vb21hdffKG0tDT5+fnpscdO/Cho//79CgwM1MGDB3XjjTdqzJgxuv322yVJn3zyiRITE/Xpp58qJCREzz33nAYPHixJevXVV/XCCy/ozTffbNBYG/VJu7q6asSIERoxYkRjDgMAnCOOHz+uTz/9VNdcc408PX+ZX/bVV1+1LTrVrl07paen6+6779a4cePsFp0ymUy2Raeio6PtFp2SZFt06vHHH7dbdEqSbdGpk88FTgdZBwAAGBlZ5+x48oW39OQL9b94fLOwRJfFPqwrQi7WxyVf6afqg3a1U02ruevbH3V++JR6+6trDuumaS803cABwIHOnTvr8OHDdvu+/vprPfPMM3YzdezatUtWq9XWJF+6dKmttm3bNgUGBkqSwsPDVVRUZGtuOKqdbG78utYQrLwIAAZnMp351tBFp0pKSlRbW6s+ffrIw8NDN9xwg3bv3t0qF50CAADG0BRZBwDOlr37Duitf39q19gAgMZqzrwzbNgwlZWV6fnnn9e3336ruXPnqri4WKNGjZLFYtFLL70k6cQdHkOGDJGzs7Pi4uK0adMmrVu3TseOHdOsWbMUExMjSRo9erSWL1+ukpIS1dTUaO7cubbamDFjNG/ePFVUVGjv3r3Kycmx1RqC5gYAGFxzLjpVVlamnj17Kjc3V9u3b5eLi4vGjx/fKhedAgAAxsCC4gAAwOiaM+907NhRa9as0eLFi9WjRw/NmTNHK1asUJcuXZSdna1JkybJz89Pr732mmbOnClJ8vPz0+zZszV06FD5+/urvLxcM2bMkCT17t1bU6ZMUb9+/RQYGChnZ2dNnDhRkhQbG6vBgwcrODhYZrNZV1xxhUaNGtXgsTb9BGAAgFalORedSkxMVGJiou3xvHnzZDabFRISUu/5Lb3oFAAAMAZ6EwAAwOiaO+9cddVVKioqqrc/Li5OO3fu1NatWxUREWG37umECRMUExOjHTt2KDIy0m668ieeeEKJiYmqqKhQVFSUXF1PrMFmMpmUm5uryZMn6+DBg4qKimpUI4bmBgAYnJPTmV8B3dzcHDYz/siFF16o2tpaderUSaWlpXa1AwcOyNXVVb6+vqqsrKy3X9Jp1wAAwLmjKbIOAABAa9aa8k6nTp00bNgwhzWz2Ww3y8avhYaGKjQ01GEtPDz8tMbCtFQAgCaTkpJit4BUUVGRnJyc1KtXL7uO/28Xnfp1zdHCUo2tAQAAAAAAwNhobgCAwTXnolO9e/fWjBkz9O677+rtt9/WhAkT9Ne//lXXX399q1t0CgAAGAMLigMAAKMj7zjGtFQAYHDNuUjmrbfeqk8//VSjR4+Ws7Ozbr31VqWnp8vFxUXZ2dlKSEhQSkqKnJyctHHjRkn2i055enrK29tbixYtkmS/6JS7u7uCg4PtFp1auXKlgoODJUmDBw9u1KJTAADAGFgQHAAAGB15xzGaGwBgcM19/cvIyFBGRka9/a1t0SkAAGAMXP4BAIDRkXcco7kBAGg2rWnRKQAAAAAAALRdNDcAwOC4mwEAABgZWQcAABgdeccxmhsAYHBcAAEAgJGRdQAAgNGRdxyjuQEABsf1DwAAGBlZBwAAGB15xzGnlh4AAAAAAAAAAABAY3DnBgAYHLcuAgAAIyPrAAAAoyPvOEZzAwAMjusfAAAwMrIOAAAwOvKOYzQ3AMDg6O4DAAAjI+sAAACjI+84xpobAAAAAAAAAACgTeHODQAwOJr7AADAyMg6AADA6Mg7jtHcAACD49ZFAABgZGQdAABgdOQdx2huAIDBcf0DAABGRtYBAABGR95xjDU3AAAAAAAAAABAm8KdGwBgcNy6CAAAjIysAwAAjI684xjNDQAwOK5/AADAyMg6AADA6Mg7jtHcAACDo7sPAACMjKwDAACMjrzjGGtuAAAAAAAAAACANoXmBgAYnMl05hsAAEBr1dxZZ/LkyTKZTLbtkksukSSVlpYqPDxcPj4+SklJUV1dne2YwsJChYSEyM/PT5mZmXbny8/PV9euXRUQEKBly5bZ1bKysuTv76+goCCtX7/+9D4gAADQ5vHdjmM0NwDA4H79x/fpbgAAAK1Vc2edLVu26M0331RVVZWqqqq0bds2Wa1WxcbGqm/fvtqyZYvKysq0aNEiSVJlZaXi4uKUkJCgoqIi5eXlacOGDZJONEQSExOVmpqqgoICpaWlqby8XJJUUFCg5ORkLVy4UEuWLFFSUpL27dvXpJ8dAABoG/huxzGaGwBgcHT3AQCAkTVn1jl+/Lg+/fRTXXPNNfL29pa3t7fOP/98rV27VtXV1crMzFT37t2Vnp6unJwcSVJeXp4CAgKUmpqq4OBgpaWl2WrZ2dmKjo5WUlKSevXqpUmTJik3N1eSNH/+fI0dO1bx8fEaOHCg4uPjtWrVqib//AAAQOvHdzuO0dwAAAAAAKABSkpKVFtbqz59+sjDw0M33HCDdu/ereLiYkVERKhdu3aSpLCwMJWVlUmSiouLFR0dbfvFZP/+/bV161ZbbdCgQbbzN7QGAAAAmhsAYHjcuggAAIysKbKO1WqVxWKx26xWa73XKisrU8+ePZWbm6vt27fLxcVF48ePl8VikdlsthuTs7Ozqqqq6tW8vLy0Z88eSTrtGgAAOLfw3Y5jNDcAwOC4AAIAACNriqyTkZGhDh062G0ZGRn1XisxMVFbtmzRn/70JwUHB2vevHl65513VFtbKzc3N7vnuru769ChQ3JxcbGrndwv6bRrAADg3MJ3O465tPQAAABnl0GvXwAAAJKaJutMnz5dU6dOtdv322aFIxdeeKFqa2vVqVMnlZaW2tUOHDggV1dX+fr6qrKyst5+SaddAwAA5xa+23GMOzcAAAAAAOc0Nzc3eXl52W2OmhspKSlaunSp7XFRUZGcnJzUq1cvFRUV2fbv2rVLVqtVvr6+Cg8Pt6tt27ZNgYGBknTaNQAAANDcAADD49ZFAABgZM2ZdXr37q0ZM2bo3Xff1dtvv60JEybor3/9q66//npZLBa99NJLkqT09HQNGTJEzs7OiouL06ZNm7Ru3TodO3ZMs2bNUkxMjCRp9OjRWr58uUpKSlRTU6O5c+faamPGjNG8efNUUVGhvXv3Kicnx1YDAADnFr7bcYzmBgAYnMl05hsAAEBr1ZxZ59Zbb9VNN92k0aNHKyEhQTfccIOee+45ubi4KDs7W5MmTZKfn59ee+01zZw5U5Lk5+en2bNna+jQofL391d5eblmzJgh6USzZMqUKerXr58CAwPl7OysiRMnSpJiY2M1ePBgBQcHy2w264orrtCoUaOa/PMDAACtX3PmncmTJ9s1RS655BJJUmlpqcLDw+Xj46OUlBTV1dXZjiksLFRISIj8/PyUmZlpd778/Hx17dpVAQEBWrZsmV0tKytL/v7+CgoK0vr16xv9udDcAACDo7sPAACMrLmzTkZGhvbv3699+/Zpzpw5at++vSQpLi5OO3fu1OLFi/XZZ58pNDTUdsyECRNUXl6uvLw8bd++Xf7+/rbaE088oW3btik/P18ffPCBPDw8bO8rNzdXhYWFWrNmjVavXk0uAwDgHNWceWfLli168803VVVVpaqqKm3btk1Wq1WxsbHq27evtmzZorKyMi1atEiSVFlZqbi4OCUkJKioqEh5eXnasGGDpBMNkcTERKWmpqqgoEBpaWkqLy+XJBUUFCg5OVkLFy7UkiVLlJSUpH379jXqc6G5AQAAAABAE+jUqZOGDRumjh071quZzWbdeOON8vT0rFcLDQ3Vdddd53DB8PDwcF177bU0NgAAwFl3/Phxffrpp7rmmmvk7e0tb29vnX/++Vq7dq2qq6uVmZmp7t27Kz09XTk5OZKkvLw8BQQEKDU1VcHBwUpLS7PVsrOzFR0draSkJPXq1UuTJk1Sbm6uJGn+/PkaO3as4uPjNXDgQMXHx2vVqlWNGi/NDQAwOKalAgAARkbWAQAARtcUecdqtcpisdhtVqvV7nVKSkpUW1urPn36yMPDQzfccIN2796t4uJiRUREqF27dpKksLAwlZWVSZKKi4sVHR1t+yFG//79tXXrVltt0KBBtvM3tNZQNDcAwOCcTKYz3gAAAForsg4AADC6psg7GRkZ6tChg92WkZFh9zplZWXq2bOncnNztX37drm4uGj8+PGyWCwym82255lMJjk7O6uqqqpezcvLS3v27JGk0641lEujng0AaHP4ex0AABgZWQcAABhdU+Sd6dOna+rUqXb73Nzc7B4nJiYqMTHR9njevHkym80KCQmp91x3d3cdOnRILi4udrWT+yWddq2haG4AAAAAAAAAAGBgbm5u9RoUf+TCCy9UbW2tOnXqpNLSUrvagQMH5OrqKl9fX1VWVtbbL+m0aw3FtFQAYHAmk+mMNwAAgNaKrAMAAIyuufJOSkqKli5dantcVFQkJycn9erVS0VFRbb9u3btktVqla+vr8LDw+1q27ZtU2BgoCSddq2haG4AgME5mc58AwAAaK3IOgAAwOiaK+/07t1bM2bM0Lvvvqu3335bEyZM0F//+lddf/31slgseumllyRJ6enpGjJkiJydnRUXF6dNmzZp3bp1OnbsmGbNmqWYmBhJ0ujRo7V8+XKVlJSopqZGc+fOtdXGjBmjefPmqaKiQnv37lVOTo6t1lBMSwUABsevEQEAgJGRdQAAgNE1V9659dZb9emnn2r06NFydnbWrbfeqvT0dLm4uCg7O1sJCQlKSUmRk5OTNm7cKEny8/PT7NmzNXToUHl6esrb21uLFi2SdKJZMmXKFPXr10/u7u4KDg7WxIkTJUmxsbFauXKlgoODJUmDBw/WqFGjGjVemhsAAAAAAAAAAEAZGRnKyMiotz8uLk47d+7U1q1bFRERoY4dO9pqEyZMUExMjHbs2KHIyEh5enraak888YQSExNVUVGhqKgo27oaJpNJubm5mjx5sg4ePKioqKhGN3FobgCAwfFjRgAAYGRkHQAAYHStJe906tRJw4YNc1gzm80ym80Oa6GhoQoNDXVYCw8PP+3x0NwAAIMzqZVcAQEAAM4Csg4AADA68o5jLCgOAAbXkots3nDDDbZ5FgsLCxUSEiI/Pz9lZmbaPS8/P19du3ZVQECAli1bZlfLysqSv7+/goKCtH79ervagw8+KB8fH4WFhWn79u2nP1AAANBmsaA4AAAwOvKOYzQ3AABnRV5engoKCiRJlZWViouLU0JCgoqKipSXl6cNGzZIkkpLS5WYmKjU1FQVFBQoLS1N5eXlkqSCggIlJydr4cKFWrJkiZKSkrRv3z5J0oIFC7RgwQKtXr1ajz/+uG6++WYdPXq0Zd4sAAAAAAAAmhXNDQAwOJPJdMZbY/3000+aNm2aevbsKelEoyMgIECpqakKDg5WWlqacnJyJEnZ2dmKjo5WUlKSevXqpUmTJik3N1eSNH/+fI0dO1bx8fEaOHCg4uPjtWrVKlstOTlZkZGRiouLU8+ePfXee+810acGAADaipbIOgAAAM2JvOMYzQ0AMDiT6cw3q9Uqi8Vit1mt1lO+5rRp0zRy5EhFRERIkoqLixUdHW27mPbv319bt2611QYNGmQ7tiG1uro6lZSUnPI4AABw7miKrAMAANCakXcco7kBAAbnZDKd8ZaRkaEOHTrYbRkZGQ5fb8OGDXr33Xc1a9Ys2z6LxSKz2Wx77OXlpT179px2raamRrW1tac8DgAAnDuaIusAAAC0ZuQdx1xaegAAgNZv+vTpmjp1qt0+Nze3es87cuSI7rzzTs2fP1/nn3++bb+Li4vd893d3XXo0KHTrrm4uNQbw6+PAwAAAAAAgLHR3AAAg2uK5rybm5vDZsZvPfbYYwoPD9ewYcPs9vv6+qqystL2+MCBA3J1dT3tmoeHhzw8PFRZWSkvL696xwEAgHOHQX+ICAAAYEPecYzmBgAYXHMuGrV06VJVVlbK29tbknTo0CGtWLFCkjRw4EDb87Zt26bAwEBJUnh4uIqKinT77befsjZ48OB6tX79+qmoqEjdu3e31U4uYA4AAM4dRl0gEwAA4CTyjmOsuQEABteci069//77Ki0t1SeffKJPPvlEcXFxevTRR7V7925t2rRJ69at07FjxzRr1izFxMRIkkaPHq3ly5erpKRENTU1mjt3rq02ZswYzZs3TxUVFdq7d69ycnLsajNnzpTFYtHnn3+u/Px8Ww0AAJw7WGATAAAYHXnHMe7cAAA0mc6dO9s99vT0lJ+fn/z8/DR79mwNHTpUnp6e8vb21qJFiyRJvXv31pQpU9SvXz+5u7srODhYEydOlCTFxsZq5cqVCg4OliQNHjxYo0aNkiTdeeedeu2119S5c2dZrVYlJSWpb9++zfdmAQAAAAAA0GJobgCAwTm1YHv+ZANDkiZMmKCYmBjt2LFDkZGR8vT0tNWeeOIJJSYmqqKiQlFRUba1M0wmk3JzczV58mQdPHhQUVFRtlsx3dzc9M4772jTpk1yc3NT//79m/W9AQCA1qElsw4AAEBzIO84RnMDAAyuNV3+zGazzGazw1poaKhCQ0Md1sLDwx3ud3JyUmRkZJONDwAAtD2tKesAAACcDeQdx2huAIDBsegUAAAwMrIOAAAwOvKOYywoDgAAAAAAAAAA2hTu3AAAg3OiuQ8AAAyMrAMAAIyOvOMYzQ0AMDhuXQQAAEZG1gEAAEZH3nGM5gYAGBzXPwAAYGRkHQAAYHTkHcdYcwMAAAAAAAAAALQp3LkBAAbHrYsAAMDIyDoAAMDoyDuO0dwAAINj0SkAAGBkZB0AAGB05B3HaG4AgMHR3QcAAEZG1gEAAEZH3nGMNTcAAAAAAAAAAECbQnMDAAzO1AQbAABAa9WSWeeGG27QokWLJEmFhYUKCQmRn5+fMjMz7Z6Xn5+vrl27KiAgQMuWLbOrZWVlyd/fX0FBQVq/fr1d7cEHH5SPj4/CwsK0ffv2MxgpAABoy/huxzGaGwBgcE4m0xlvAAAArVVLZZ28vDwVFBRIkiorKxUXF6eEhAQVFRUpLy9PGzZskCSVlpYqMTFRqampKigoUFpamsrLyyVJBQUFSk5O1sKFC7VkyRIlJSVp3759kqQFCxZowYIFWr16tR5//HHdfPPNOnr0aBN8YgAAoK3hux3HaG4AgMGZTGe+AQAAtFYtkXV++uknTZs2TT179pR0otEREBCg1NRUBQcHKy0tTTk5OZKk7OxsRUdHKykpSb169dKkSZOUm5srSZo/f77Gjh2r+Ph4DRw4UPHx8Vq1apWtlpycrMjISMXFxalnz5567733muZDAwAAbQrf7ThGcwMADM5kMp3xBgAA0Fq1RNaZNm2aRo4cqYiICElScXGxoqOjbefq37+/tm7daqsNGjTIdmxDanV1dSopKTnlcQAA4NzCdzuO0dwAAAAAAJzTrFarLBaL3Wa1Wh0+d8OGDXr33Xc1a9Ys2z6LxSKz2Wx77OXlpT179px2raamRrW1tac8DgAAADQ3AMDwuHURAAAYWVNknYyMDHXo0MFuy8jIqPdaR44c0Z133qn58+fr/PPPt+13cXGRm5ub7bG7u7sOHTp02jUXFxdJOuVxAADg3MJ3O465tPQAAABnl1EXjQIAAJCaJutMnz5dU6dOtdv368bCSY899pjCw8M1bNgwu/2+vr6qrKy0PT5w4IBcXV1Pu+bh4SEPDw9VVlbKy8ur3nEAAODcwnc7jnHnBgAYHN19AABgZE2Rddzc3OTl5WW3OWpuLF26VK+99pq8vb3l7e2tpUuXauLEiVq8eLGKiopsz9u2bZsCAwMlSeHh4adV69ev3ylrAADg3NJS3+3ccMMNWrRokSSpsLBQISEh8vPzU2Zmpt3z8vPz1bVrVwUEBGjZsmV2taysLPn7+ysoKEjr16+3qz344IPy8fFRWFiYtm/f3ujx0dwAAAAAAKAB3n//fZWWluqTTz7RJ598ori4OD366KPavXu3Nm3apHXr1unYsWOaNWuWYmJiJEmjR4/W8uXLVVJSopqaGs2dO9dWGzNmjObNm6eKigrt3btXOTk5drWZM2fKYrHo888/V35+vq0GAABwtuXl5amgoECSVFlZqbi4OCUkJKioqEh5eXnasGGDJKm0tFSJiYlKTU1VQUGB0tLSVF5eLkkqKChQcnKyFi5cqCVLligpKUn79u2TJC1YsEALFizQ6tWr9fjjj+vmm2/W0aNHGzVGmhsAYHAmk+mMNwAAgNaqObNO586d1a1bN9vm6ekpPz8/+fn5afbs2Ro6dKj8/f1VXl6uGTNmSJJ69+6tKVOmqF+/fgoMDJSzs7MmTpwoSYqNjdXgwYMVHBwss9msK664QqNGjZIk3XnnnbrwwgvVuXNn9erVS7fddpv69u3b9B8gAABo9Zr7u52ffvpJ06ZNU8+ePSWdaHQEBAQoNTVVwcHBSktLU05OjiQpOztb0dHRSkpKUq9evTRp0iTl5uZKkubPn6+xY8cqPj5eAwcOVHx8vFatWmWrJScnKzIyUnFxcerZs6fee++9Ro2zxdfcqNr8XEsPAQAMjS420LLIOgBwdrVk1jk5TYMkTZgwQTExMdqxY4ciIyPl6elpqz3xxBNKTExURUWFoqKibGtnmEwm5ebmavLkyTp48KCioqJsXz64ubnpnXfe0aZNm+Tm5qb+/fs363sDGoqsAwBnX3PnnWnTpmnkyJE6fPiwJKm4uFjR0dG2nNK/f3/df//9ttqNN95oO7Z///569NFHbbVbbrnFrvbee+/p9ttvV0lJiRYuXGhX27p1q4YMGdLgcbZ4cwMAcHZx5wUAADCy1pR1zGazzGazw1poaKhCQ0Md1sLDwx3ud3JyUmRkZJONDwAAtE1NkXesVqusVqvdPjc3t3rrjG3YsEHvvvuuPv30U91zzz2SJIvFYpdjvLy8tGfPHlvt1/mnIbWamhrV1tbWq33++eeNek/8oBcAAAAAAAAAAAPLyMhQhw4d7LaMjAy75xw5ckR33nmn5s+fr/PPP9+238XFxa4J4u7urkOHDp12zcXlxD0XpzquobhzAwAMzqn1/JgRAACgyZF1AACA0TVF3pk+fbqmTp1qt++3d2089thjCg8P17Bhw+z2+/r6qrKy0vb4wIEDtmk2T6fm4eEhDw8PVVZWysvLq95xDUVzAwAMjj/4AQCAkZF1AACA0TVF3nE0BdVvLV26VJWVlfL29pYkHTp0SCtWrJAkDRw40Pa8bdu2KTAwUNKJ6TWLiop0++23n7I2ePDgerV+/fqpqKhI3bt3t9VOLmDeUExLBQAGZzKZzngDAABorcg6AADA6Jor77z//vsqLS3VJ598ok8++URxcXF69NFHtXv3bm3atEnr1q3TsWPHNGvWLMXExEiSRo8ereXLl6ukpEQ1NTWaO3eurTZmzBjNmzdPFRUV2rt3r3JycuxqM2fOlMVi0eeff678/HxbraG4cwMAAAAAAAAAgHNc586d7R57enrKz89Pfn5+mj17toYOHSpPT095e3tr0aJFkqTevXtrypQp6tevn9zd3RUcHKyJEydKkmJjY7Vy5UoFBwdLkgYPHqxRo0ZJku6880699tpr6ty5s6xWq5KSktS3b99GjddUV1dXd4bv+YwcOd6Srw4ArY97E7edU94oP+NzPDW8cbcFAvgFWQcA7JF1AGMh6wCAvabOOlLryTu7du3Sjh07FBkZKU9PT7taWVmZKioqFBUVVW/tjM2bN+vgwYOKioqyu4uktrZWmzZtkpubm/r379/o8XDnBgAYHDMtAAAAIyPrAAAAo2stecdsNstsNjushYaGKjQ01GEtPDzc4X4nJydFRkae9nhobgCAwTm1lisgAADAWUDWAQAARkfecYwFxQEAAAAAAAAAQJvCnRsAYHB0sQEAgJGRdQAAgNGRdxyjuQEABsediwAAwMjIOgAAwOjIO47R3AAAg2NeRgAAYGRkHQAAYHTkHce4owUAAAAAAAAAALQp3LkBAAZHcx8AABgZWQcAABgdeccxmhsAYHBOLXQB3L9/v8rLy9WjRw/5+Pi0zCAAAIDhtVTWAQAAaC7kHceYlgoADM7JZDrjrbFWrlypbt26KSkpSZ07d9bKlSslSaWlpQoPD5ePj49SUlJUV1dnO6awsFAhISHy8/NTZmam3fny8/PVtWtXBQQEaNmyZXa1rKws+fv7KygoSOvXrz+NTwgAALRlLZF1AAAAmhN5xzGaGwCAJlVdXa2JEyfqvffeU0lJibKyspSSkiKr1arY2Fj17dtXW7ZsUVlZmRYtWiRJqqysVFxcnBISElRUVKS8vDxt2LBB0omGSGJiolJTU1VQUKC0tDSVl5dLkgoKCpScnKyFCxdqyZIlSkpK0r59+1rqrQMAAAAAAKCZ0NwAAIMzmc58awyLxaJnnnlGYWFhkqQrr7xS+/bt09q1a1VdXa3MzEx1795d6enpysnJkSTl5eUpICBAqampCg4OVlpamq2WnZ2t6OhoJSUlqVevXpo0aZJyc3MlSfPnz9fYsWMVHx+vgQMHKj4+XqtWrWq6Dw8AALR6zZ11AAAAmht5xzGaGwBgcE6mM9+sVqssFovdZrVaHb5ely5dlJiYKEk6duyYZs+erZEjR6q4uFgRERFq166dJCksLExlZWWSpOLiYkVHR8v0v6tt//79tXXrVltt0KBBtvM3tAYAAM4NTZF1AAAAWjPyjmM0NwDA4ExN8E9GRoY6dOhgt2VkZPzu6xYXF6tTp0566623NHfuXFksFpnN5l/GZTLJ2dlZVVVV9WpeXl7as2ePJJ12DQAAnBuaIusAAAC0ZuQdx2huAAD+0PTp01VdXW23TZ8+/XePCQsL09tvv63g4GAlJSXJxcVFbm5uds9xd3fXoUOH6tVO7pd02jUAAAAAAAAYl0tLDwAAcHY1xa2Hbm5u9RoTf8RkMqlv375avHixunfvroyMDJWWlto958CBA3J1dZWvr68qKyvr7Zd02jUAAHBuMOo0CwAAACeRdxzjzg0AMLjmnpexsLBQKSkptseurq4ymUwKCQlRUVGRbf+uXbtktVrl6+ur8PBwu9q2bdsUGBgoSaddAwAA5wbmoAYAAEZH3nGM5gYAGJzJZDrjrTF69OihhQsXauHChfrmm2/0wAMP6Prrr9fQoUNlsVj00ksvSZLS09M1ZMgQOTs7Ky4uTps2bdK6det07NgxzZo1SzExMZKk0aNHa/ny5SopKVFNTY3mzp1rq40ZM0bz5s1TRUWF9u7dq5ycHFsNAACcG5o76wAAADQ38o5jNDcAAE3qoosuUn5+vubMmaPLLrtMhw4d0j//+U+5uLgoOztbkyZNkp+fn1577TXNnDlTkuTn56fZs2dr6NCh8vf3V3l5uWbMmCFJ6t27t6ZMmaJ+/fopMDBQzs7OmjhxoiQpNjZWgwcPVnBwsMxms6644gqNGjWqxd47AAAAAAAAmoeprq6uriUHcOR4S746ALQ+7k28GtI/Cv97xueYFhXUBCM54fvvv9fWrVsVERGhjh072tV27dqlHTt2KDIyUp6enna1srIyVVRUKCoqqt66Gps3b9bBgwcVFRVl2F8joO0i6wCAPaNnHeBcQ9YBAHtNnXUk8s6psKA4ABhca/uuv1OnTho2bJjDmtlsltlsdlgLDQ1VaGiow1p4eHiTjQ8AALQtrS3rAAAANDXyjmM0NwDA4Jy4AgIAAAMj6wAAAKMj7zjGmhsAAAAAAAAAAKBN4c4NADA4J5r7AADAwMg6AADA6Mg7jtHcAACD485FAABgZGQdAABgdOQdx2huAIDBOYkrIAAAMK6Wyjr79+9XeXm5evToIR8fnxYZAwAAODfw3Y5jrLkBAAAAAEAjrFy5Ut26dVNSUpI6d+6slStXSpJKS0sVHh4uHx8fpaSkqK6uznZMYWGhQkJC5Ofnp8zMTLvz5efnq2vXrgoICNCyZcvsallZWfL391dQUJDWr19/9t8cAABAG0FzAwAMzmQ68w0AAKC1au6sU11drYkTJ+q9995TSUmJsrKylJKSIqvVqtjYWPXt21dbtmxRWVmZFi1aJEmqrKxUXFycEhISVFRUpLy8PG3YsEHSiYZIYmKiUlNTVVBQoLS0NJWXl0uSCgoKlJycrIULF2rJkiVKSkrSvn37mvLjAwAAbQDf7ThGcwMADM7JdOYbAABAa9XcWcdiseiZZ55RWFiYJOnKK6/Uvn37tHbtWlVXVyszM1Pdu3dXenq6cnJyJEl5eXkKCAhQamqqgoODlZaWZqtlZ2crOjpaSUlJ6tWrlyZNmqTc3FxJ0vz58zV27FjFx8dr4MCBio+P16pVq5ruwwMAAG0C3+04RnMDAAzOyWQ64w0AAKC1aoqsY7VaZbFY7Dar1erw9bp06aLExERJ0rFjxzR79myNHDlSxcXFioiIULt27SRJYWFhKisrkyQVFxcrOjpapv/lqv79+2vr1q222qBBg2znb2gNAACcO/huxzGaGwAAAACAc1pGRoY6dOhgt2VkZPzuMcXFxerUqZPeeustzZ07VxaLRWaz2VY3mUxydnZWVVVVvZqXl5f27NkjSaddAwAAOJv279+vjz76SFVVVS09lFOiuQEABse8jAAAwMiaIutMnz5d1dXVdtv06dN/93XDwsL09ttvKzg4WElJSXJxcZGbm5vdc9zd3XXo0KF6tZP7JZ12DQAAnDua+7udlStXqlu3bkpKSlLnzp21cuVKSSfWCgsPD5ePj49SUlJUV1dnO6awsFAhISHy8/NTZmam3fny8/PVtWtXBQQEaNmyZXa1rKws+fv7KygoSOvXr2/UOGluAIDBcesiAAAwsqbIOm5ubvLy8rLbftuo+C2TyaS+fftq8eLFeuWVV+Tr66vKykq75xw4cECurq71aif3SzrtGgAAOHc053c71dXVmjhxot577z2VlJQoKytLKSkpslqtio2NVd++fbVlyxaVlZVp0aJFkqTKykrFxcUpISFBRUVFysvL04YNGySdaIgkJiYqNTVVBQUFSktLU3l5uSSpoKBAycnJWrhwoZYsWaKkpCTt27ev4Z9Lwz9CAEBbxJ0bAADAyJo76xQWFiolJcX22NXVVSaTSSEhISoqKrLt37Vrl6xWq3x9fRUeHm5X27ZtmwIDAyXptGsAAODc0Zx5x2Kx6JlnnlFYWJgk6corr9S+ffu0du1aVVdXKzMzU927d1d6erpycnIkSXl5eQoICFBqaqqCg4OVlpZmq2VnZys6OlpJSUnq1auXJk2apNzcXEnS/PnzNXbsWMXHx2vgwIGKj4/XqlWrGjxWmhsAAAAAADRQjx49tHDhQi1cuFDffPONHnjgAV1//fUaOnSoLBaLXnrpJUlSenq6hgwZImdnZ8XFxWnTpk1at26djh07plmzZikmJkaSNHr0aC1fvlwlJSWqqanR3LlzbbUxY8Zo3rx5qqio0N69e5WTk2OrAQAAnA1dunRRYmKiJOnYsWOaPXu2Ro4cqeLiYkVERKhdu3aSTkzRWVZWJunEWmTR0dEy/a+L0r9/f23dutVWGzRokO38Da01hMsZvE8AQBtAFxsAABhZc2ediy66SPn5+frb3/6m5ORkxcTE6J///KdcXFyUnZ2thIQEpaSkyMnJSRs3bpQk+fn5afbs2Ro6dKg8PT3l7e1tm8ahd+/emjJlivr16yd3d3cFBwdr4sSJkqTY2FitXLlSwcHBkqTBgwdr1KhRzfyOAQBAS2uKvGO1WmW1Wu32ubm5nXIqzpONB1dXV3322Wd67LHHZDabbXWTySRnZ2dVVVXJYrEoNDTUVvPy8tKePXsknbgT5NfHNbTWEHznBQAGZzKZzngDAABorVoi61x33XX69NNPZbFYtHLlSl1wwQWSpLi4OO3cuVOLFy/WZ599ZvdH/oQJE1ReXq68vDxt375d/v7+ttoTTzyhbdu2KT8/Xx988IE8PDxs7y03N1eFhYVas2aNVq9eTTYDAOAc1BR5JyMjQx06dLDbMjIyTvmaYWFhevvttxUcHKykpCS5uLjUa4S4u7vr0KFD9Won90s67VpDcOcGABgcf/4CAAAja21Zp1OnTho2bJjDmtlstvt14q+FhobaNUN+LTw8vMnGBwAA2p6myDvTp0/X1KlT7fad6q4N6URDpW/fvlq8eLG6d++ujIwMlZaW2j3nwIEDcnV1la+vryorK+vtl3TatYbgzg0AAAAAAAAAAAzMzc1NXl5edpuj5kZhYaFSUlJsj11dXWUymRQSEqKioiLb/l27dslqtcrX11fh4eF2tW3btikwMFCSTrvWEDQ3AMDgnEymM94AAABaK7IOAAAwuubMOz169NDChQu1cOFCffPNN3rggQd0/fXXa+jQobJYLHrppZckSenp6RoyZIicnZ0VFxenTZs2ad26dTp27JhmzZqlmJgYSdLo0aO1fPlylZSUqKamRnPnzrXVxowZo3nz5qmiokJ79+5VTk6Ordagz6URnyEAoA0yNcEGAADQWpF1AACA0TVn3rnooouUn5+vOXPm6LLLLtOhQ4f0z3/+Uy4uLsrOztakSZPk5+en1157TTNnzpQk+fn5afbs2Ro6dKj8/f1VXl6uGTNmSJJ69+6tKVOmqF+/fgoMDJSzs7MmTpwoSYqNjdXgwYMVHBwss9msK664QqNGjWr451JXV1fXiPfW5I4cb8lXB4DWx72JV0Na+p9vz/gct1zZuQlGApybyDoAYI+sAxgLWQcA7DV11pFaV975/vvvtXXrVkVERKhjx452tV27dmnHjh2KjIyUp6enXa2srEwVFRWKioqqt67G5s2bdfDgQUVFRcnUiLtMWFAcAAAAAAAAAAD8oU6dOmnYsGEOa2azWWaz2WEtNDRUoaGhDmvh4eGnNRaaGwBgcI3peAMAALQ1ZB0AAGB05B3HaG4AgMGxuBIAADAysg4AADA68o5jNDcAwODo7gMAACMj6wAAAKMj7zhG0wcAAAAAAAAAALQp3LkBAAZHbx8AABgZWQcAABgdeccxmhsAYHDcuggAAIyMrAMAAIyOvOMYzQ0AMDjmHwQAAEZG1gEAAEZH3nGMzwUAAAAAAAAAALQp3LkBAAbHrYsAAMDIyDoAAMDoyDuO0dwAAIPj8gcAAIyMrAMAAIyOvOMYzQ0AMDia+wAAwMjIOgAAwOjIO47R3AAAg3Oivw8AAAyMrAMAAIyOvOMYC4oDAAAAAAAAAIA2hTs3AMDguHURAAAYGVkHAAAYHXnHMZobAGBwJm5dBAAABkbWAQAARkfecYzmBgAYHN19AABgZGQdAABgdOQdx1hzAwDQ5F577TUFBQXJxcVFffr00WeffSZJKi0tVXh4uHx8fJSSkqK6ujrbMYWFhQoJCZGfn58yMzPtzpefn6+uXbsqICBAy5Yts6tlZWXJ399fQUFBWr9+/dl/cwAAAAAAAGhxNDcAwOCcZDrjrTF27typcePG6cknn1RFRYV69OihpKQkWa1WxcbGqm/fvtqyZYvKysq0aNEiSVJlZaXi4uKUkJCgoqIi5eXlacOGDZJONEQSExOVmpqqgoICpaWlqby8XJJUUFCg5ORkLVy4UEuWLFFSUpL27dvXpJ8fAABo3Zo76wAAADQ38o5jNDcAwOBMpjPfGuOzzz7Tk08+qT//+c/y9/fXXXfdpW3btmnt2rWqrq5WZmamunfvrvT0dOXk5EiS8vLyFBAQoNTUVAUHBystLc1Wy87OVnR0tJKSktSrVy9NmjRJubm5kqT58+dr7Nixio+P18CBAxUfH69Vq1Y16ecHAABat+bOOgAAAM2NvOMYzQ0AMLimuABarVZZLBa7zWq1Ony94cOHa/z48bbH5eXlCg4OVnFxsSIiItSuXTtJUlhYmMrKyiRJxcXFio6Olul/V9v+/ftr69atttqgQYNs52toDQAAnBv4Yx8AABgdeccxmhsAgD+UkZGhDh062G0ZGRl/eNzRo0f1j3/8QxMmTJDFYpHZbLbVTCaTnJ2dVVVVVa/m5eWlPXv2SNJp1wAAAAAAAGBcNDcAwOBMTfDP9OnTVV1dbbdNnz79D1/7oYceUvv27ZWUlCQXFxe5ubnZ1d3d3XXo0KF6tZP7JZ12DQAAnBuaIusAAAC0ZuQdx1xaegAAgLPLqQmuX25ubvUaE39k/fr1ysrK0ocffqjzzjtPvr6+Ki0ttXvOgQMH5OrqKl9fX1VWVtbbL+m0awAA4NzQFFkHAACgNSPvOMadGwBgcC3R3d+1a5cSEhKUlZWl0NBQSVJ4eLiKiorsnmO1WuXr61uvtm3bNgUGBjo8rqE1AABwbuCXjAAAwOjIO47R3AAANKnDhw9r+PDhio+P18iRI1VTU6OamhpFRkbKYrHopZdekiSlp6dryJAhcnZ2VlxcnDZt2qR169bp2LFjmjVrlmJiYiRJo0eP1vLly1VSUqKamhrNnTvXVhszZozmzZuniooK7d27Vzk5ObYaAAAAAAAAjItpqQDA4EzN3Jx/++23VVZWprKyMr3wwgu2/bt27VJ2drYSEhKUkpIiJycnbdy4UZLk5+en2bNna+jQofL09JS3t7cWLVokSerdu7emTJmifv36yd3dXcHBwZo4caIkKTY2VitXrlRwcLAkafDgwRo1alSzvl8AANCymjvrAAAANDfyjmOmurq6upYcwJHjLfnqAND6uDdx23lj+U9nfI5re/o2wUhO+P7777V161ZFRESoY8eOdrVdu3Zpx44dioyMlKenp12trKxMFRUVioqKqreuxubNm3Xw4EFFRUXJxBUfrQxZBwDsGT3rAOcasg4A2GvqrCORd06FaakAwOCcTGe+NaVOnTpp2LBh9RobkmQ2m3XjjTfWa2xIUmhoqK677jqHC4aHh4fr2muvpbEBADgrLBaLtm8vlqW6uqWHAgdaIuu89tprCgoKkouLi/r06aPPPvtMklRaWqrw8HD5+PgoJSVFv/4tYWFhoUJCQuTn56fMzEy78+Xn56tr164KCAjQsmXL7GpZWVny9/dXUFCQ1q9f3/jBAgDwB8g6rV9r+26ntaC50YY9mf64el/W07YNv+G6lh4SDK6q6ifdeP0gVVR867B+1/jb9dqqV2yP81f8S4Ojrlbf3pfp/8beqsrKH5prqAAAA3glf6WuHxylAX176/bb/qJvv/mmpYcEg3OUdd4uWKuh1w/SI2kzdN3gKL1dsNZWe3XVyxoVP1xXR/TTfclTVVV15r+oQ+u3c+dOjRs3Tk8++aQqKirUo0cPJSUlyWq1KjY2Vn379tWWLVtUVlZmm2azsrJScXFxSkhIUFFRkfLy8rRhwwZJJxoiiYmJSk1NVUFBgdLS0lReXi5JKigoUHJyshYuXKglS5YoKSlJ+/bta6m3DqCJcR1Bc2ts1iGPo7WjudGGlX1aqufmL9T7RZv1ftFm/evlVS09JBhYVdVPumfiBO2pqHBYf/ON1fpg079tj/+zdYuynpujJ56cpTUF76qurk6ZT81sruHiV0xN8A8ANLdvdu/WgvlZmvPsPL36+lp17tJFqQ/e39LDgoE5yjoHDhxQ+mOP6MXFS/Tyq6/rgQfTNPvppyRJHxZ9oJnpjyvlvula+cpqHTxYo3snT2qp4Z/TmjvrfPbZZ3ryySf15z//Wf7+/rrrrru0bds2rV27VtXV1crMzFT37t2Vnp6unJwcSVJeXp4CAgKUmpqq4OBgpaWl2WrZ2dmKjo5WUlKSevXqpUmTJik3N1eSNH/+fI0dO1bx8fEaOHCg4uPjtWoVf/cBRsB1BM2tsVmHPN668N2OYzQ32qjjx49r55dfqG/ffvLy8pKXl5fat68/jQvQVO5Lnqobhw13WKvev1//mDVT3cxm277du79W6kOPKuJPA+XfqZPiR47Sjv/dro/mZTKd+QYAzW3HZ2UK691bIaGX6aKAAI0YOVrf7P66pYcFA3OUdQ7W1Cjl/gfUo+elkqSQ0FDt318lSXp99auKGzFKfxp4lS4KCNC90/6ubf/Zqur9+5t76Oe8psg6VqtVFovFbrNarQ5fb/jw4Ro/frztcXl5uYKDg1VcXKyIiAi1a9dOkhQWFqaysjJJUnFxsaKjo21TaPbv319bt2611QYNGmQ7X0NrANo2riNobo3NOuTx1qW5v9tpK1Nw0txoo7744nPV1tbqz6NHqP+VYbpr/O36bs+elh4WDCztkceUeOtfHdaefmqmBg0ZorCwPrZ9I0aO1qDBQ2yPv9q1Sxd37Xq2hwkHTE2wAUBzC+p+iT7+6EPt+OwzHThwQCuWL1XEn65q6WHBwBxlnU4XXaRhw+MkSceOHVPuPxdr0JATU8Hur6rSRRddZHuus/OJP62cnJ2bacQ4qSmyTkZGhjp06GC3ZWRk/OFrHz16VP/4xz80YcIEWSwWmX/1Yx+TySRnZ2dVVVXVq3l5eWnP//5+O90agLaN6wiaW2OzDnm8dWnO73ba0hScNDfaqP/u/FLdzGY98eQsrVy1Ws4uLnr04dSWHhYMrHPnLg73f/zRh/r4wyLdOy3llMdW79+v/JX/0v+76eazNTwAgMF0v+QSDbk+RjeNGaGrI/qpuPgTTU25r6WHBQM7VdaRpPIdOzQ46mp98O/3dd/0GZKkkJBQvVe4UbW1tZKk115dpcsu76Xzzz+/WcaLpjV9+nRVV1fbbdOnT//D4x566CG1b99eSUlJcnFxkZubm13d3d1dhw4dqlc7uV/SadcAtG1cR9DcGpt1yOPnrrY0BWezNjcac6svft+w4XFatuIV9e5zhbp27aYHZzykD4s+UE1NTUsPDecQq9Wqxx55SA+mPfy706KlP/6o+vS5QldHRjXj6HCSk8l0xhuAhiHrNJ2S7dtVuHGDcpet0L8/3KIbhw7XpAl32N32DDSXHj176vkXcnRx1656JO3EH/x/HXe7amtrdfOYkfrLLTfpxeyFSki8tYVHem5qiqzj5uZmm+735PbbRsVvrV+/XllZWVq6dKnOO+88+fr6qrKy0u45Bw4ckKura73ayf2STrsGtASyTtPhOoLWxFHWIY+3Ls353U5bmoKzWZsbjm71fWrmH9/qiz/m27Gjamtr9WPlDy09FJxDFj4/T5dffrmuibr2lM9Z/eoqbf74Iz3yWHrzDQx2mJYKaD5knabz1po3dMONwxQW1lvnn3++Jk3+m7755huV79jR0kPDOchkMin0ssv1WPqTenfd27JYLPLy8tKi3KV6evZc9ejZU+agIA0dFtvSQz0ntUTW2bVrlxISEpSVlaXQ0FBJUnh4uIqKiuyeY7Va5evrW6+2bds2BQYGOjyuoTWgJZB1mg7XEbQmjrIOebx1aYq8czoN6tY+BadLQ5+4e/fuBj3v4osvPmVt+vTpmjp1qt2+Ouff/zUMHMt8eqYuvTRUQ4efuPAVf7JNTk5O8u900R8cCTSdNW++rqqfqnR1RD9J0uHDR/R2wVqVlmzXg2kP69PSEj2Z/pjmPDdfHf38Wni05zC6E0CDkHVal9q6WlX/VGV7fPDgQR05cli1tT+34Khwrtmy+WO9V7hBU5NPTMFw3nmuMplMcnL65TdiF1x4od5d947SHn5MzsyT3jKaOescPnxYw4cPV3x8vEaOHGm7ez4yMlIWi0UvvfSSxo0bp/T0dA0ZMkTOzs6Ki4vT3XffrXXr1ikqKkqzZs1STEyMJGn06NG66qqrNGXKFJnNZs2dO1e33nri19tjxozRhAkTNG7cOLm4uCgnJ0dz5sxp3jcMwyDrtE5cR9CSfi/rkMdbmSbIOxkZGXrkkUfs9j300EN6+OGHT3nMr6fgnDFjRqubgrPBzY1rr71WX3/9tSSd8vYjk8mkn38+9f/A3dzc6n0AR443dAT4tR49L9Vzzz6jjn5++vnnn/Vk+mMaHjdCHh4eLT00nEMW/XOpjv/8y/+JM5+apbDevRU3YqT27dunyXffpdv+L0mXXXa5Dh08KElq1759Sw0XAH4XWad1ufLKfprx4P3KXbxIHTt21Csvr5Sf3wUK7tGzpYeGc0jXbt308qQVuvjibro68ho9N/cZ/WngVfL0/GU6zmV5uTKbgzRo8JAWHCma09tvv62ysjKVlZXphRdesO3ftWuXsrOzlZCQoJSUFDk5OWnjxo2SJD8/P82ePVtDhw6Vp6envL29bQtw9u7dW1OmTFG/fv3k7u6u4OBgTZw4UZIUGxurlStXKjg4WJI0ePBgjRo1qlnfL4yDrNM6cR1BS/q9rEMeNx5HDerfm4bz5BScH374oW0KztLSUrvntPQUnA1ubnz88ceKjY1VYmKiJk2a1OAXwNkxPDZeO7/8UtP+do+cnJw1LDZW90yZ+scHAk3Iv1Mnu8ft2rWTt7ePfHx8lZe7WD/+WKmsZ+co69lffl1W/Gl5cw/znGfi1g2gQcg6rcuQ62P03//uVF7uYlVWVuqS4GBlzn1O5513XksPDeeQCy64UE/PnqtZT6Yr8+mZGnjV1Xo8Y5atbqmu1qIXczRvwQu/cxacbc2ddeLj40/5xXC3bt20c+dObd26VREREerYsaOtNmHCBMXExGjHjh2KjIy0a5I98cQTSkxMVEVFhaKiomx/1JtMJuXm5mry5Mk6ePCgoqKibHNZA41F1ml9uI6gpf1e1iGPty5NkXccNahP5VRTcP72hx2/noJz6dKltpqjaTZvv/32U9YGDx5cr9YQprpGrALz448/KiEhQdnZ2eratWuDX+T30OEHAHvuDW47N8zH/60+43P0D+rQBCMBWj+yDgCcfWQdoOWQdQDg7GvqrCM1b945fPiw+vXrp6uuukqZmZm2/W5ubgoMDNTMmTM1btw43XHHHfr+++/1+uuv68cff1SXLl30+uuvKyoqSnFxcbrkkkv07LPPqri4WFdddZWKiopkNpsVGRmpW2+9VdOmTdPq1as1YcIEbd68WS4uLurbt6/mzJmj0aNHN2isjWpunA1cBAHAXlNfBDc3wQUwnD/4gdNG1gEAe2QdwFjIOgBg72w0N5oz77z22msaMWJEvf27du3S9u3blZCQIA8PD9sUnCfv7Hj++ec1efJk2xScRUVF8vf3lyQ9+OCDevrpp21TcL7//vvy8PBQXV2d/vrXv+rll1+WdGIKztWrVzf4TlWaGwDQyvAHP2AsZB0AsEfWAYyFrAMA9tp6c+OPfP/99w6n4JRONEAcTcEpSWVlZfWm4Dxp8+bNpzUFJ80NAGhlmvwP/l1NcAE08wc/cLrIOgBgj6wDGAtZBwDsnZXmBnnHobPwUQMAWhMWFAcAAEZG1gEAAEZH3nGM5gYAGFwj7uYDAABoc8g6AADA6Mg7jjm19AAAAAAAAAAAAAAagzs3AMDgaO4DAAAjI+sAAACjI+84RnMDAIyOKyAAADAysg4AADA68o5DNDcAwOBYdAoAABgZWQcAABgdeccx1twAAAAAAAAAAABtCnduAIDBmWjuAwAAAyPrAAAAoyPvOEZzAwAMjusfAAAwMrIOAAAwOvKOYzQ3AMDouAICAAAjI+sAAACjI+84xJobAAAAAAAAAACgTeHODQAwOBPtfQAAYGBkHQAAYHTkHcdobgCAwbHoFAAAMDKyDgAAMDryjmM0NwDA4Lj+AQAAIyPrAAAAoyPvOMaaGwAAAAAAAAAAoE3hzg0AMDra+wAAwMjIOgAAwOjIOw7R3AAAg2PRKQAAYGRkHQAAYHTkHcdobgCAwbHoFAAAMDKyDgAAMDryjmOsuQEAAAAAAAAAANoU7twAAIOjuQ8AAIyMrAMAAIyOvOMYzQ0AMDqugAAAwMjIOgAAwOjIOw7R3AAAg2PRKQAAYGRkHQAAYHTkHcdYcwMAAAAAAAAAALQpNDcAwOBMpjPfGuvHH3+U2WzWV199ZdtXWlqq8PBw+fj4KCUlRXV1dbZaYWGhQkJC5Ofnp8zMTLtz5efnq2vXrgoICNCyZcvsallZWfL391dQUJDWr1/f+IECAIA2ryWyDgAAQHMi7zhGcwMADM7UBFtj/Pjjjxo+fLhdY8NqtSo2NlZ9+/bVli1bVFZWpkWLFkmSKisrFRcXp4SEBBUVFSkvL08bNmyQdKIhkpiYqNTUVBUUFCgtLU3l5eWSpIKCAiUnJ2vhwoVasmSJkpKStG/fvtP4hAAAQFvW3FkHAACguZF3HKO5AQBG18xXwJtvvlm33HKL3b61a9equrpamZmZ6t69u9LT05WTkyNJysvLU0BAgFJTUxUcHKy0tDRbLTs7W9HR0UpKSlKvXr00adIk5ebmSpLmz5+vsWPHKj4+XgMHDlR8fLxWrVrV+M8HAAC0bfy1DwAAjI684xDNDQDAH7JarbJYLHab1Wp1+NwXXnhBkydPtttXXFysiIgItWvXTpIUFhamsrIyWy06Olqm/90j2b9/f23dutVWGzRokO08Da0BAAAAAADA2GhuAIDBmZrgn4yMDHXo0MFuy8jIcPh6ZrO53j6LxWK332QyydnZWVVVVfVqXl5e2rNnj8PjGloDAADnjqbIOgAAAK0Zeccxl5YeAADg7GqKRaOmT5+uqVOn2u1zc3Nr8PEuLi71nu/u7q5Dhw7Vq53c7+i4htYAAMC5w6gLZAIAAJxE3nGMOzcAwOCaYlpGNzc3eXl52W2NaW74+vqqsrLSbt+BAwfk6upar3Zyv6PjGloDAADnjpaYgvrHH3+U2WzWV199ZdtXWlqq8PBw+fx/9u4/Pud6/+P489qWbaxh1pmGGI2skJikNDOlZFvhlOEU31ZHEiVOLabfFokoP9KEWBTloENKfhxHq3DW0DInTT8mGq3Nzytl3z8c13G1C9tc23V93nvcz+1z+36vz/v6fK73tbPb+Tzt9Xl93nXratSoUSopKXGMbdiwQS1btlRoaKgmTZrkdK4lS5aocePGCg8P18KFC53Gpk2bprCwMDVt2lRr166twEwBAIAJWHLDNYobAIBKFx0drczMTMfrvLw82e12hYSElBrLyspSgwYNXB5X1jEAAIDKcuDAAfXs2dOpsGG32xUfH6927dppy5YtysnJ0dy5cyVJBQUFSkhIUFJSkjIzM5WRkaF169ZJOlUQ6d+/v1JTU7V69WqNHTtWubm5kqTVq1dr5MiRmjVrlhYsWKDk5GQdPHiwqr8uAACA16K4AQCm84Ly/o033qji4mLNmTNHkjRu3Dh169ZNvr6+SkhI0KZNm7RmzRqdOHFCEyZMUPfu3SVJvXv31qJFi7R9+3YdPnxYU6dOdYz16dNH06dPV35+vvbv36/Zs2c7xgAAQDVSxVmnb9++6tevn9O+VatWqaioSJMmTVKzZs00btw4zZ49W5KUkZGh8PBwpaamKjIyUmPHjnWMpaenKzY2VsnJyWrVqpWGDh2q+fPnS5JmzJihe+65R4mJierUqZMSExO1dOnS8v98AACA9VVx3rFKlyrFDQAwnDcsOuXn56f09HQNHTpUoaGhWrZsmcaPHy9JCg0N1eTJk9WjRw+FhYUpNzdXY8aMkSS1adNGw4cPV/v27dWgQQP5+vpqyJAhkqT4+HjFxcUpMjJSERERatu2rXr16nXBcwUAANbijqxjt9tVXFzstNntdpef9/rrr2vYsGFO+7Kzs9WxY0fVrFlTktS6dWvl5OQ4xmJjY2X778OyO3TooK1btzrGunbt6jhPWccAAED1UpV/27FSlyrFDQAwnM124VtFlJSUqEmTJo7XCQkJ2r17t+bNm6evvvpKUVFRjrHBgwcrNzdXGRkZ2rZtm8LCwhxjzz//vLKysrRkyRJ98sknCgwM/O/3smn+/PnasGGDVq5cqeXLlzv+aAAAAKoPd2SdtLQ01a5d22lLS0tz+XkRERGl9hUXFzvtt9ls8vX1VWFhYamx4OBg7d271+VxZR0DAADVS1X+bcdKXaoUNwAAVaZ+/fq67bbbVK9evVJjERERuvXWWxUUFFRqLCoqSjfddJPLBcOjo6PVpUsXChsAAKDCUlJSVFRU5LSlpKSU+Xg/Pz/5+/s77QsICNDRo0dLjZ3e7+q4so4BAACUV1k7Va3UpUpxAwAM5wVLbgAAAFQad2Qdf39/BQcHO21/LFacS0hIiAoKCpz2HTp0SDVq1Cg1dnq/q+PKOgYAAKoXd+SdsnaqWqlLleIGAJiO6gYAADCZF2Sd6OhoZWZmOl7n5eXJbrcrJCSk1FhWVpYaNGjg8riyjgEAgGrGDXnnQjpVvbVLleIGABjOGxYUBwAAqCzekHVuvPFGFRcXa86cOZKkcePGqVu3bvL19VVCQoI2bdqkNWvW6MSJE5owYYK6d+8uSerdu7cWLVqk7du36/Dhw5o6dapjrE+fPpo+fbry8/O1f/9+zZ492zEGAACqF3fknQvpVPXWLlWKGwAAAAAAXAA/Pz+lp6dr6NChCg0N1bJlyzR+/HhJUmhoqCZPnqwePXooLCxMubm5GjNmjCSpTZs2Gj58uNq3b68GDRrI19dXQ4YMkSTFx8crLi5OkZGRioiIUNu2bdWrVy+PfUcAAFB9eWuXqq2kpKSkQt/ITY7/5slPBwDvE+Dn3vN993PpxaHK67KQsj9zGoAzsg4AODM56+zbt09bt25Vx44dVa9ePaexvLw87dy5U507d1ZQUJDTWE5OjvLz8xUTE1PqjsXNmzfryJEjiomJcSzUCXgTsg4AOHN31pE8k3dsNpvy8vLUpEkT/fbbbwoPD9f48eM1aNAg3Xfffdq3b59WrFihAwcOqFGjRlqxYoViYmKUkJCgyy+/XK+88oqys7N1/fXXKzMzUxEREercubMGDBigRx99VMuXL9fgwYO1efNm+fn5qV27dpoyZYp69+5d9jlS3AAA7+Lui+D3brgANqK4AVQYWQcAnJF1ALOQdQDAWWUUNzyRd84sbkjS8uXLlZSUpMDAQPn4+Gj9+vWKioqSJM2cOVPDhg1TUFCQ6tSpo8zMTIWFhUmSRo8erYkTJyogIECRkZHauHGjAgMDVVJSorvvvlvvvvuuJCkuLk7Lly8v180cFDcAwMu4+yL4Q+GFXwAb1uUf/EBFkXUAwBlZBzALWQcAnFVGccNb8o63dalS3AAAL+P+f/D/esHnaFi3fAs6Afgfsg4AOCPrAGYh6wCAs8opbpB3XGFBcQAAAAAAAAAAYCmVUEcCAHgT1p0EAAAmI+sAAADTkXdco7gBAIbj+gcAAExG1gEAAKYj77hGcQMADEd1HwAAmIysAwAATEfecY01NwAAAAAAAAAAgKXQuQEAhrPRvAgAAAxG1gEAAKYj77hGcQMATMf1DwAAmIysAwAATEfecYniBgAYjusfAAAwGVkHAACYjrzjGmtuAAAAAAAAAAAAS6FzAwAMZ6O8DwAADEbWAQAApiPvuEZxAwAMx6JTAADAZGQdAABgOvKOaxQ3AMB0XP8AAIDJyDoAAMB05B2XWHMDAAAAAAAAAABYCp0bAGA4ivsAAMBkZB0AAGA68o5rFDcAwHAsOgUAAExG1gEAAKYj77hGcQMADMeiUwAAwGRkHQAAYDryjmusuQEAAAAAAAAAACyFzg0AMBytiwAAwGRkHQAAYDryjmt0bgAAAAAAAAAAAEuhcwMADEd1HwAAmIysAwAATEfecY3ODQAAAAAAAAAAYCl0bgCA4WyivA8AAMxF1gEAAKYj77hGcQMADEfrIgAAMBlZBwAAmI684xrFDQAwHNc/AABgMrIOAAAwHXnHNdbcAAAAAAAAAAAAlkLnBgCYjvI+AAAwGVkHAACYjrzjEsUNADAci04BAACTkXUAAIDpyDuuUdwAAMOx6BQAADAZWQcAAJiOvOMaa24AAAAAAAAAAABLoXMDAAxHcR8AAJiMrAMAAExH3nGN4gYAmI4rIAAAMBlZBwAAmI684xLFDQAwHItOAQAAk5F1AACA6cg7rrHmBgAAAAAAAAAAsBQ6NwDAcDaK+wAAwGBkHQAAYDryjmu2kpKSEk9PAhVnt9uVlpamlJQU+fv7e3o6qMb4XQQAVAauL/Am/D4CANyNawu8Cb+PsBqKGxZXXFys2rVrq6ioSMHBwZ6eDqoxfhcBAJWB6wu8Cb+PAAB349oCb8LvI6yGNTcAAAAAAAAAAIClUNwAAAAAAAAAAACWQnEDAAAAAAAAAABYCsUNi/P399eTTz7JIj/wOH4XAQCVgesLvAm/jwAAd+PaAm/C7yOshgXFAQAAAAAAAACApdC5AQAAAAAAAAAALIXiBgAAAAAAAAAAsBSKGwAAAAAAAAAAwFIobljYjh07FB0drbp162rUqFFi+RR40oEDBxQREaE9e/Z4eioAAEOQdeBNyDoAAHcj68CbkHVgRRQ3LMputys+Pl7t2rXTli1blJOTo7lz53p6WqimDhw4oJ49e3IBBAC4DVkH3oSsAwBwN7IOvAlZB1ZFccOiVq1apaKiIk2aNEnNmjXTuHHjNHv2bE9PC9VU37591a9fP09PAwBgELIOvAlZBwDgbmQdeBOyDqyK4oZFZWdnq2PHjqpZs6YkqXXr1srJyfHwrFBdvf766xo2bJinpwEAMAhZB96ErAMAcDeyDrwJWQdWRXHDooqLixUREeF4bbPZ5Ovrq8LCQg/OCtXVmb+LAAC4A1kH3oSsAwBwN7IOvAlZB1ZFccOi/Pz85O/v77QvICBAR48e9dCMAAAA3IesAwAATEbWAYALR3HDokJCQlRQUOC079ChQ6pRo4aHZgQAAOA+ZB0AAGAysg4AXDiKGxYVHR2tzMxMx+u8vDzZ7XaFhIR4cFYAAADuQdYBAAAmI+sAwIWjuGFRN954o4qLizVnzhxJ0rhx49StWzf5+vp6eGYAAAAXjqwDAABMRtYBgAtnKykpKfH0JFAxy5cvV1JSkgIDA+Xj46P169crKirK09NCNWaz2ZSXl6cmTZp4eioAAAOQdeBtyDoAAHci68DbkHVgNRQ3LG7fvn3aunWrOnbsqHr16nl6OgAAAG5F1gEAACYj6wBAxVHcAAAAAAAAAAAAlsKaGwAAAAAAAAAAwFIobgAAAAAAAAAAAEuhuAEAAAAAAAAAACyF4gYAAAAAAAAAALAUihsAAAAAAAAAAMBSKG4AAAAAAAAAAABLobgBAAAAAAAAAAAsheIGAAAAAAAAAACwFIobAAAAAAAAAADAUihuAAAAAAAAAAAAS6G4AQAAAAAAAAAALIXiBgAAAAAAAAAAsBSKGwAAAAAAAAAAwFIobgAAAAAAAAAAAEuhuAEAAAAAAAAAACyF4gYAAAAAAAAAALAUihsAAAAAAAAAAMBSKG4AAAAAAAAAAABLobgBAAAAAAAAAAAsheIGAAAAAAAAAACwFIobAAAAAAAAAADAUihuAAAAAAAAAAAAS6G4AQAAAAAAAAAALIXiBgAAAAAAAAAAsBSKGwAAAAAAAAAAwFIobgBuVFxc7OkpAAAAVBqyDgAAMBlZB7AWihvV3Pr162Wz2VxuTz31lCSpS5cujv/fUwYOHKiBAwe65Vxz585VkyZN3P65e/bsUZs2bZSTk1PxyZXRO++8o+bNm6tu3bq6//77dfz48Qqf6/vvv1dwcLDWr1/vvgkCAOAlyDru+1wrZZ0nn3yy1H/fN9xwQyXNFgAAzyHruO9zrZR1Ttu3b5/q1q2riRMnunmGgDVQ3Kjm2rVrp82bN2vz5s3q2bOnmjdv7nh9//33e3p6ltKkSRPNnDlTt956q7Kysirtc9asWaOkpCTdfPPNWrRokbZt26ZHHnmkwue77777dOjQITfOEAAA70HWcR8rZZ2tW7fqr3/9q+O/682bN2v27NmVNGMAADyHrOM+Vso6pz388MMKCwvT8OHD3TxLwBr8PD0BeNbFF1+s9u3bS5Lq1aunwMBAx2uUX/fu3ZWRkaHbb79dCxcuVKdOndz+GWPHjlX37t316quvSpKaNWumli1b6qmnnlJYWFi5zjVnzhxlZma6fY4AAHgLso57WSXr/Pvf/9Y999zDf9cAAOORddzLKllHklavXq23335bq1ev1kUXXeT2eQJWQOcG4GY33HCDli5dqv79+2vt2rWO/Xv27Dlrq6jNZivTY6EOHz6szz77TP3793fsu/zyy9WyZUunzyqLvXv3asSIEZo0aVK5jgMAANWbt2edH3/8UT/++CN/2AEAABXi7VlHko4dO6YhQ4bo9ttv180331yu7weYhOIGyuyNN95QkyZNFBwcrH79+jk9D/D0Mwx/+OEHJSUlKTQ0VN9++61j/Pjx445Wubp16+quu+5SQUGB0/nHjx+vJk2aqGbNmmrXrp3Li8KKFSvUsmVL1apVS7feeqsOHDjgGPvxxx915513KigoSGFhYXr88cf122+/les7zps3T40bN1bNmjU1aNAg/frrr+U6/rRrrrlGK1eu1P3336/3339fkhQeHq6srKyzbmX5B/i+fft08uRJtW7d2ml/06ZN9Z///Kdccxw8eLCuu+463XvvveU6DgAAU5F1ys6bs86///1v+fr6ql+/fqpZs6YaNWqk1NRUnThxovxfFAAAg5B1ys6bs44kjRs3Tt988418fHw0YMAAvfTSS7Lb7eX7koABeCwVyuTvf/+7jh49qsmTJ+vgwYN64IEH1KlTJw0dOtTxnp9//lnXX3+9YmJi9NRTTykkJMQx9sADD+ijjz7Sq6++qlq1amnkyJHq1auXNm7c6Dj/448/rkmTJunqq6/WggULdPvtt2v//v3y9/eXJG3ZskVr1qzRCy+8oBo1aui+++7TCy+8oIkTJ+rYsWOKi4uTj4+PFi1apP3792vkyJE6cOCA0tPTy/QdMzMzNXDgQA0ZMkS9evXSa6+95qjUV0TLli310Ucf6ZZbbtHRo0d155136uqrr67QuU47duyYJKlOnTpO+4OCgkqFinPJyMjQxo0btWPHjguaDwAApiDrlJ+3Zp3PP/9cNWrUUGJiop577jl9/vnnGjt2rCTp2WefvaD5AQBgVWSd8vPWrLN//3699NJLkqQffvhBF110kd566y0tWbJE69evd/y8geqA4gbKZNeuXdq1a5caNmwoSVq6dKmys7Od3rNixQq9/PLLpRYx2rNnj+bNm6d3331Xd9xxhyTpt99+U2JiovLy8hQREaG8vDxddNFFuv/++1WrVi1dc801uuOOO/T77787zpOTk6PPP//cUQnfsGGDYw6LFi1Sbm6udu7cqcjISEmSj4+P7r33Xo0ZM0ZNmjQ573ecMmWKrrzySk2bNk3SqTbEshx3LoWFhfrtt98UGhrq+N5n4+vrK5vNds7znb5A+fr6Ou232WyOC+T5/PTTTxo+fLimTJmiBg0alOkYAABMR9apGG/MOn/96181YMAAx88pLi5OR48e1Wuvvaann35aPj40rwMAqh+yTsV4Y9ZZsGCBjh07psmTJ+vhhx+WJL3//vuKj4/Xm2++qfvuu69M5wFMQLJHmdx+++2OC6AkXXLJJaVa+6+88ko99NBDpY7dvn27SkpK1KtXL8dzCBMTEyXJ0XLXu3dv1a1bV1dddZXuu+8+vffee4qJiVHNmjUd5+nYsaNTi9+Zc9iyZYsaNWrkuABKUrdu3VRSUqItW7aU6Tvu2rVLHTp0cLz29/fXtddeW6ZjXVm/fr369OmjhQsXqmvXrtqzZ48uuuiis24bNmw47zn/9Kc/STpVmT/TwYMHVatWrTLNa8iQIbr++ut19913l/9LAQBgKLJO+Xlr1gkPD3f6OUnS9ddfr4KCAuXn55fx2wEAYBayTvl5a9bZtWuXgoKC9MADDzj29ezZUw0aNFBWVlY5viFgfXRuoEyaNWt23ve0b9/+nHfCffDBBwoLC3Pa17RpU0nSZZddpl27dumDDz7Qv/71L40ePVrPPvusvvjiCwUHB593DiUlJRUaO9PJkydLVc7/+Lqsli5dqpEjR+r9999XVFSUpP89m/FsLr/88vOet06dOrrsssv0r3/9y3HBLikp0b///W/FxMSUaW7vvvuuJJW6myA2NlYxMTFlWgALAADTkHXKx5uzzueff66GDRsqPDzcse/gwYOS5PRscQAAqhOyTvl4c9apVauWGjRoUOrxU4GBgapRo0aZzgGYgs4NlElFLwbSqcq/JNntdl199dW6+uqrFRYWpokTJzoWp0pPT9f69et111136ZVXXtGGDRuUl5enjz/+uExziI6O1vfff6/du3c79q1du1Y2m61MCzpJpy5CZ94NcOLECX3++efl+q6SNHv2bKWkpOjjjz92XAAlqUaNGo7v72oLCgoq0/n79Omj6dOnq7i4WJL09ttva//+/erWrVuZjne16JUkvf7662V+jiUAAKYh65Sdt2edYcOGacqUKU773nzzTV1yySVl+sMOAAAmIuuUnbdnnejoaH333XcqLCx07NuzZ4/27NlzQZ0qgBXRuYFK17RpU/3lL3/Rgw8+qEOHDik8PFxpaWn68ssvNWPGDEmnFkN6+umnZbfb1bBhQy1evFiSFBERUabP6Nu3ryZMmKA77rhD48aN008//aSRI0dq0KBBZT7Hgw8+qK5du+qRRx5RfHy83njjjXI/umDChAl66623tH79etWvX79cx5bVY489poULFyo6OlodOnTQO++8o4SEBLVr106SdOjQIeXm5urKK69UYGBgqePPtvjV5ZdfXqa7DAAAgDOyjntdaNZ56KGHNHDgQPn6+qpZs2b6+9//rg8//FDTpk1jvQ0AACqArONeF5p1evXqpSeffFK33367UlJSdOzYMT355JNq0qSJevXqVSlzBrwV6R5VYubMmbrjjjv0yCOPKCEhQb6+vlqzZo0uvvhiSdLf/vY39e/fX3/729/UtWtX/eMf/1B6evpZ/xD/R4GBgVq7dq1atGihu+66S48//rjuv/9+vfbaa2WeY2xsrObPn6+VK1eqZ8+eOn78uHr37l3m43fv3q2VK1dW6gVQOvV8xi1btujaa6/Vjh079Mgjj2jRokWO8a1btyo6Olq5ubmVNgcAAOCMrOM+F5p1+vfvr8mTJysjI0NDhw7Vvn37tHDhQg0ZMqTS5gwAgOnIOu5zoVnH399fGzZsUOPGjXXPPffoL3/5i+rXr69Vq1aVelQVYDpbSVkfXAcAAAAAAAAAAOAF6NwAAAAAAAAAAACWQnEDAAAAAAAAAABYCsUNAAAAAAAAAABgKRQ3AAAAAAAAAACApVDcAAAAAAAAAAAAlkJxAwAAAAAAAAAAWArFDQAAAAAAAAAAYCl+np5AYNuhnp4CIEna98lUT08BkCTVDnRv3dkd/zt7LOtVN8wEqJ7IOvAWP31K1oF3uNifrAOYhKwDb3Hgs1c8PQVAklSrhs3t5yTvuObx4gYAoJLZaNIDAAAGI+sAAADTkXdc4qcCAAAAAAAAAAAshc4NADCdzf3tkAAAAF6DrAMAAExH3nGJ4gYAmI7WRQAAYDKyDgAAMB15xyV+KgBgOpvtwrdySk9PV6NGjVSzZk116dJF33zzjSRpx44dio6OVt26dTVq1CiVlJQ4jtmwYYNatmyp0NBQTZo0yel8S5YsUePGjRUeHq6FCxc6jU2bNk1hYWFq2rSp1q5dW4EfEAAAsDQPZB0AAIAqRd5xieIGAMCtdu/erWeeeUbLli3Tzp071axZMw0cOFB2u13x8fFq166dtmzZopycHM2dO1eSVFBQoISEBCUlJSkzM1MZGRlat26dpFMFkf79+ys1NVWrV6/W2LFjlZubK0lavXq1Ro4cqVmzZmnBggVKTk7WwYMHPfXVAQAAAAAAUEUobgCA6Ww+F76VQ1ZWljp27KhrrrlGl112mf7v//5PX3/9tVatWqWioiJNmjRJzZo107hx4zR79mxJUkZGhsLDw5WamqrIyEiNHTvWMZaenq7Y2FglJyerVatWGjp0qObPny9JmjFjhu655x4lJiaqU6dOSkxM1NKlS9378wMAAN6tirMOAABAlSPvuGTmtwIA/I8bWhftdruKi4udNrvd7vLjoqKitHbtWn3xxRcqKirS9OnTddNNNyk7O1sdO3ZUzZo1JUmtW7dWTk6OJCk7O1uxsbGy/bdNskOHDtq6datjrGvXro7zl3UMAABUEzyCEwAAmI7HUrlEcQMATOeG6n5aWppq167ttKWlpbn8uKioKPXp00dt27ZVnTp1lJmZqYkTJ6q4uFgRERH/m5bNJl9fXxUWFpYaCw4O1t69eyWpwmMAAKCaqOI7GXkEJwAAqHJ0brhk5rcCALhVSkqKioqKnLaUlBSX7/3888+1YsUKffrpp/rll1+UlJSkHj16yM/PT/7+/k7vDQgI0NGjR0uNnd4vqcJjAAAAlYFHcAIAAHgHihsAYDo3tC76+/srODjYaftjoeK0hQsXqm/fvrr22mtVu3ZtPffcc9q9e7dCQkJUUFDg9N5Dhw6pRo0apcZO75dU4TEAAFBNVPFjGngEJwAAqHJVnHes8ghOihsAYLoqbl08efKkfvrpJ8frQ4cOObozMjMzHfvz8vJkt9sVEhKi6Ohop7GsrCw1aNBAkio8BgAAqgk3ZJ3yri/GIzgBAECVqsK/7VjpEZwUNwDAdFVc3e/cubPee+89TZ48WW+99ZZuv/121a9fX8OGDVNxcbHmzJkjSRo3bpy6desmX19fJSQkaNOmTVqzZo1OnDihCRMmqHv37pKk3r17a9GiRdq+fbsOHz6sqVOnOsb69Omj6dOnKz8/X/v379fs2bMdYwAAoJpwQ9Ypz/piPIITAABUuSr8246VHsFJcQMA4Fa9e/fW448/rpdfflkDBw7UL7/8oqVLl+qiiy5Senq6hg4dqtDQUC1btkzjx4+XJIWGhmry5Mnq0aOHwsLClJubqzFjxkiS2rRpo+HDh6t9+/Zq0KCBfH19NWTIEElSfHy84uLiFBkZqYiICLVt21a9evXy2HcHAADWVJ71xXgEJwAAsKKydqpa6RGcFDcAwHRV/Fgqm82m1NRUffvtt/r111/173//W23btpUkJSQkaPfu3Zo3b56++uorRUVFOY4bPHiwcnNzlZGRoW3btiksLMwx9vzzzysrK0tLlizRJ598osDAQMdnzZ8/Xxs2bNDKlSu1fPlyx4UUAABUE27IOuVZX4xHcAIAgCrnhrxT1k5VKz2Ck+IGAJiuih9LdT7169fXbbfdpnr16pUai4iI0K233qqgoKBSY1FRUbrppptc3q0YHR2tLl26UNgAAKA64hGcAADAdG7IO2XtVLXSIzj9yvxOAIA1lbPzAgAAwFKqOOv07t1bX331lV5++WX9+OOPuuqqq5wewZmUlKRRo0bJx8dH69evl+T8CM6goCDVqVPHsQDnmY/gDAgIUGRkpNMjOBcvXqzIyEhJUlxcHI/gBACgOnJD3vH39z9rZ+qZznwEpyQ999xzmjFjhvr06aMdO3Y4vdfTj+DkL14AAAAAAJQRj+AEAAAms9IjOCluAIDpqnjNDQAAgCrlZVmHR3ACAAC3q8K8Y6VHcPJYKgAwnQ//CAYAAAYj6wAAANNVYd6x0iM4bSUlJSVu/fblFNh2qCc/HnDY98lUT08BkCTVDnTv3YOBXZ+/4HMcWzvaDTMBqieyDrzFT5+SdeAdLvYn6wAmIevAWxz47BVPTwGQJNWq4f5ChDflnX379mnr1q3q2LFjqU7VvLw87dy5U507dy7VqZqTk6P8/HzFxMSU6lTdvHmzjhw5opiYmHJ1qtK5AQCm4/EFAADAZGQdAABgOi/KO6cfwelKRESEIiIiXI5FRUU5rUd2pujo6ArNhQepAwAAAAAAAAAAS6FzAwBMx4LgAADAZGQdAABgOvKOSxQ3AMB0XtS6CAAA4HZkHQAAYDryjksUNwDAdFT3AQCAycg6AADAdOQdl/ipAAAAAAAAAAAAS6FzAwBMR+siAAAwGVkHAACYjrzjEsUNADAdrYsAAMBkZB0AAGA68o5LFDcAwHRU9wEAgMnIOgAAwHTkHZco+QAAAAAAAAAAAEuhcwMATEfrIgAAMBlZBwAAmI684xLFDQAwHa2LAADAZGQdAABgOvKOSxQ3AMB0VPcBAIDJyDoAAMB05B2X+KkAAAAAAAAAAABLoXMDAExHdR8AAJiMrAMAAExH3nGJ4gYAmI7nMgIAAJORdQAAgOnIOy5R3AAA01HdBwAAJiPrAAAA05F3XOKnAgAAAAAAAAAALIXODQAwHa2LAADAZGQdAABgOvKOSxQ3AMB0tC4CAACTkXUAAIDpyDsuUdwAANNR3QcAACYj6wAAANORd1yi5AMAAAAAAAAAACyFzg0AMJyN6j4AADAYWQcAAJiOvOMaxQ0AMBwXQAAAYDKyDgAAMB15xzUeSwUAprO5YSuHuXPnymazldrmzp2rDRs2qGXLlgoNDdWkSZOcjluyZIkaN26s8PBwLVy40Gls2rRpCgsLU9OmTbV27VqnsdGjR6tu3bpq3bq1tm3bVr7JAgAA66virAMAAFDlyDsuUdwAALhVv379VFhY6Ni+//57hYaGqmXLlkpISFBSUpIyMzOVkZGhdevWSZJ27Nih/v37KzU1VatXr9bYsWOVm5srSVq9erVGjhypWbNmacGCBUpOTtbBgwclSa+99ppee+01LV++XM8995z69u2rX3/91WPfHQAAAAAAAFWD4gYAGM5VF0V5t/KoUaOG6tSp49jefPNN3XHHHcrMzFR4eLhSU1MVGRmpsWPHavbs2ZKk9PR0xcbGKjk5Wa1atdLQoUM1f/58SdKMGTN0zz33KDExUZ06dVJiYqKWLl3qGBs5cqQ6d+6shIQEtWjRQv/85z/d+wMEAABeraqzDgAAQFUj77hGcQMADOfJC+Dx48c1ZcoUPfHEE8rOzlZsbKzjfB06dNDWrVslSdnZ2eratavjuLKMlZSUaPv27Wc9DgAAVA9VnXV4BCcAAKhqFDdcY0FxADCcOy5gdrtddrvdaZ+/v7/8/f3Pedxbb72la6+9Vk2aNFFxcbGioqIcY8HBwdq7d68kqbi4WBEREeUaO3z4sE6ePFlqbNeuXRX/ogAAwHKq+h/r/fr10+233+54ffjwYbVt21YtW7bUzTffrEcffVRJSUnq27ev2rZtq9jYWMcjOKdNm6Zrr71WvXr10jXXXKMWLVo4HsG5aNEiXXLJJRowYIA2b96sevXqOT2Cs7CwUH379tUXX3yhGjVqVOl3BgAAnmVqceJC0bkBADivtLQ01a5d22lLS0s773EzZ87U4MGDJUl+fn5OxZCAgAAdPXq0wmN+fqfq82c7DgAAoDLwCE4AAGAyK3WpUtwAAMO5o3UxJSVFRUVFTltKSso5P/frr7/W119/rZtuukmSFBISooKCAsf4oUOHHHcdVmQsMDBQgYGBZz0OAABUDzyCEwAAmK4q806/fv1UWFjo2L7//nuFhoaqZcuWSkhIUFJSkjIzM5WRkaF169ZJkqNLNTU1VatXr9bYsWOVm5srSY4u1VmzZmnBggVKTk7WwYMHJcmpS/W5555T37599euvv5Z5rhQ3AMB0tgvf/P39FRwc7LSd75FU77zzjnr27KmLLrpIkhQdHa3MzEzHeFZWlho0aHBBY+3btz/rGAAAqCbckHXsdruKi4udtj8+ktOVPz6Cs7yP2TzX2NkewXn6OAAAUI24Ie+UlZW6VCluAIDhPHU34wcffKAuXbo4XickJGjTpk1as2aNTpw4oQkTJqh79+6SpN69e2vRokXavn27Dh8+rKlTpzrG+vTpo+nTpys/P1/79+/X7NmzncbGjx+v4uJi7dq1S0uWLHGMAQCA6sEdWYdHcAIAAG/mqb/teHuXKguKAwDc7tixY/rss880a9Ysx77Q0FBNnjxZPXr0UFBQkOrUqaO5c+dKktq0aaPhw4erffv2CggIUGRkpIYMGSJJio+P1+LFixUZGSlJiouLU69evSRJf/3rX7Vs2TI1bNhQdrtdycnJateuXdV+WQAAYHkpKSkaMWKE077zdalW5SM4g4ODSx0HAABQHna7vVRnqr+//zkzzx+7VKOiohxjldWlumvXrjJ/Jzo3AMBwnqjuBwYGym6364orrnDaP3jwYOXm5iojI0Pbtm1TWFiYY+z5559XVlaWlixZok8++USBgYGO+c+fP18bNmzQypUrtXz5csec/P399dFHH+kf//iHNm7cqGnTpl3ATwoAAFiRO7IOj+AEAADezFOdqt7epUpxAwAM56nWxbOJiIjQrbfeqqCgoFJjUVFRuummm1zekRgdHa0uXbqUmo+Pj486d+6sDh06uHWeAADAGngEJwAAMJ078k5KSoqKioqctpSUlLN+ZlV2qbo6riwobgCA4bytuAEAAOBOnsg6px/B2alTJ8e+Mx/BGRYWptzcXI0ZM0aS8yM4GzRoIF9fX6dHcMbFxSkyMlIRERFq27at0yM4//SnP6lhw4Zq1aqVBg4cyCM4AQCohjzRqWqFLlWKGwAAAAAAlAOP4AQAAKazQpcqC4oDgOlovAAAACbzsqwTERHhtDDmmaKiopwW4jxTdHS0y/2nH8EJAACqsSrOO6e7VGfNmuXYd2aXalBQkOrUqaO5c+dKcu5SDQgIUGRkpFOX6uLFixUZGSlJiouLc+pSXbZsmRo2bCi73a7k5ORydalS3AAAw/FYKQAAYDKyDgAAMF1V553TXap/NHjwYHXv3l07d+5U586dndZTff7559W/f3/l5+crJibGsXbG6S7VYcOG6ciRI4qJiSnVpbpp0yb5+/uXez1VihsAYDj+wQ8AAExG1gEAAKbzprzjTV2qrLkBAAAAAAAAAAAshc4NADCcN1X3AQAA3I2sAwAATEfecY3iBgCYjusfAAAwGVkHAACYjrzjEsUNADAc1X0AAGAysg4AADAdecc11twAAAAAAAAAAACWQucGABiO6j4AADAZWQcAAJiOvOMaxQ0AMBwXQAAAYDKyDgAAMB15xzWKGwBgOC6AAADAZGQdAABgOvKOa6y5AQAAAAAAAAAALIXODQAwHcV9AABgMrIOAAAwHXnHJYobAGA4WhcBAIDJyDoAAMB05B3XKG4AgOG4AAIAAJORdQAAgOnIO66x5gYAAAAAAAAAALAUOjcAwHBU9wEAgMnIOgAAwHTkHdcobgCA6bj+AQAAk5F1AACA6cg7LvFYKgDndKi4WDu2Z6u4uMjTU0EF2Wy2C94AoLLUDgpU9FWNVefiQE9PBYBFkXUAeDOyDgB3IO+4RnHDCwy84zr9Z9WzOvjJJK1+fbiaNKgnSerZpZVyVjylQ5un6NNFj6tFRJjjmLONDYi/VseyXi21DYi/1ukz/fx8tPmdJ9S5XWTVfVFYzpoPP1Bij256/ulU9bw5Vms+/ECStPvrXbqn358V1/laTZ30okpKShzHLF3yjm7t1lnXtW+lv977Fx0o+KlMYwAAc50t6/Tq1lY7Vz6t6WP76+vVz6lXt7ZOx9WrU0tfvf+ULrs0xGn/S3/r45Rzdix7skzHAX+0ft3HSrz1Jl3b9ir1+/Mdyvtmt2Psl8JCJdzSTXvz8896/EOD79OKZUsdrx95aIjat27p2IbcN6hS5w8A8A4VzTqS9NywRC15+a9O+/6S0FFbFj+hH/85QfPSBqpenVrn/SzgbAoLC9Xzljjtzf/BsW9C2nO6ptUVji2hx82OsWVL39Wf74jXjZ2ilfK3ESosLHSMLX13sW7t1kWdoq/WfYP+oh++/75KvwvwRxQ3PCyiYaieuO9W/fmR13R1r2f1zQ8Fev2ZvyiiYahee2qAUqcuU7PuY/T1tz9pxth+jmPONvb2qi2q33mUY7u8+xgVFB7SpqzdTp874p6bdFVkeJV/X1jH4UOHNCHtGb32xnwtXLJcf0tJ1SuTX9Svv/6qEcOG6IqoKzXvrcXK++Zrvf/ff9R/kbVVr02fqqefG6+//+MjlZSUaMqkF887hspFdR+AJ50t6wQHBejlJ+7UTfe+rOg7x+nhtHc07pHbHcfVq1NL700ZrCYNQkud85qoy3T7Q9Mdeadj0gtlOg440w/ff6dnUkdr6MMjtHLNel3WuImefSpV0qnCxsNDB2vv3rMXNlb9Y4UyP/mX076vcnZo0bvLtO5fn2ndvz7TS1OmVep3wClkHQCeVNGsI0lXRYbr/js7a+SLSxz7Yq9toZf+1kd/m/ieOtyZpotrBejtl+4752cBZ1NYWKjhQweXulkj58sdmjrtNW3Y9Lk2bPpcCxe/J0n6LPMTvfjC83p01ON6+91lOnL4iB59eKgk6fvvv9PrM6dr0tRpenf5SjVsdJmeHJNS5d+puiLvuEZxw8OuvqKhPt++R1/s/EHf7yvUm3//VM0aXaIrIuordepyvftRln76+ZBmLd6oNi0aSdI5x0789ruKDh9zbP16dtDytduU98MBx2c2u+wSPXx3nPbkH3A5J0CSjhw5rBEjUxTZvIUkqUXLKBUV/aJP/vVPHTl8WI88+pgaNrpMDzz0iJb//V1J0vfffqvHxzylDh07KSysvuITemlX7lfnHUPl4gIIwJPOlnWCawXoby++qx3/2StJ+mLn9wqp/b+7Et98YZDe/mBLqfP5+vqoZdNL9a+tXzvyzuGj9vMeB/xR3je7NfThEbqp+62qVy9Ufe7sq9ydp7LJE38boVt69DzrsUVFv+jliRPUuEmEY99P+/erpKREl0c218XBwbo4OFiBNWtW+vcAWQeAZ1U069hsNk0bk6RXMtZpT/5Bx/7+PTtowYrPtPaznfp+X6GeePnvuv6ay1U3uOZZPws4m5RRI3Rrj9uc9v3222/6ZvfXuqZ9e0dmqVUrSJL0/oplik+8Qx07Xa9LLw3Xw4+O0hf/3qqiol+U+1WOWrVuo5ZRV+rSS8OVeEdvff/9t574WtUSece1Chc3ioqK9OOPP+rgwYNOj6RB+Xz1zT7FRDdX6+YNFBwUoPvv7KyPP92pVRt36I33Njne17xJmL7+/tQjfM41dib/Gn56sF8XTZi92mn/q6P76qU5H+q7HwtLHQOcFlb/Ut1yW7wk6bcTJ7RwwTzFdO2m/+zK1VWtWisg8NTzQiObt3A8wiH+9l7q0rWb4xzffpunRpc1Pu8YKhcXQKBiyDrucbas88P+X7Ro1akihJ+fjx7q31XL12U7jhvyzEJNX7ih1PmuujxcPj42fbYoRT9nTtKyV4eoUf265z0O+KPOMbHq1edOx+s9e/J02X+zyegnn1Xf/me/E/bliRPUpWucWrVu49j35Y5tOvn7SfXo1kU3dLhGKX8bwZplVYSsA1QMWcc9Kpp17utzg66MDNe3ew/qtphWusjPV5JUr06Qvv/xZ8f7fv/95Kn/e/LkWT8LOJvUp55VUv+7nfZ9/Z9dOnnypPr2uUPXtW+jBwcn68cfTxXhfiksVP1L//ekFx8fn//+X181bXa5Nn/+qXJ3fqVDhw5p8aK31PG6TlX3Zao58o5r5SpuzJs3T507d1a9evXUvHlzXXvttbr88ssVFBSkxMRE7dzJ/6CW185v9mnpx1/os7dTtH/jRF3bOkIpk5c6veciP18N/0tXpS/5V6njzzV2163ttXnHt/rujIviXxI6KjgoUJPf/Nj9XwZG2pW7U7d066zMTzZq5N9G68iRwwpv0NAxbrPZ5OPrU+of70VFv2jpknfUq89dpc55rjEA8CSyjvudL+u0at5Aez5K002dWurR8f97JMO3ew+6Op1aNq2vXd/+pHtT31T0XWn67feTenVM0nmPA87lxIlflfHmHPX+86ls0qBhw7O+d8vnn+nzzz7VsBGjnPbvyctTZIsWennaTM1dsEh7f8jXq1MmV+q8AaC8yDruV5GsUyuwhsY80EN5PxzUZZeG6KH+sVo75xEF+F+kL776XrfeeJXjD5F/SeioLTv2qPjw8TL9DQk4k6tM883u3WrcJELPjhuvt99dJl9fXz339FhJ0hUto7RxwzqdPHmqqLZi2VJdeVUrXXzxxWra7HLF3dRdSX++QzGdorUt+ws98uhjVfp9gD8qc3Hjscce05IlSzRt2jQdPHhQ+/fv13fffafCwkLt2LFDf/rTn9SlSxenRWb+yG63q7i42GkrOfm7W76IVbW/srFuu/Eq3fiXFxXWeaTe+WCr/v7KA07vSX3gNh059qvmLP2k1PHnGruvzw1KX7LR8Tq0bpCeeShBg5/O0MmT3JWBsols3kKvzJitRpc11vPPpMrX11cX1ajh9J4aNfx1/Nhxp30vpj2r1m2uVqcbbix1znONoRLY3LAB1QBZp3KcL+ts35Wv+CGvavf3BZrxZL/znm/Rqi26of8EfbYtT7u/K9DDaW8rruMVurhWQGV+DRjutemvKjCwpm7v1eec77Pb7Rr37JNKGTNWtWrVchoblHy/ps96Q81bXKHLmzfX8BEj9fFHq89yJrgVWQcoE7JO5ahI1kmMu1q1Avx1y/1T9NzMlbrtgVcVVDNA/W7roJff/Fg+NpsyFz6m9fMe1aj/u1nTF20o02cBZdGjZ7wy3n5Xba5uq8saN1HKmCf1WeYnOnz4sO4e+H86WVKifnf20j3979Kc2a/rrn4DJEk7tm/TPzes07yMt7Xhk83q3uM2PTTkfjq/qgp5x6UyFzfS09M1depUtW7dutRYRESEXn/9df3+++/69NNPz3qOtLQ01a5d22n7bf/Wis3cEHfe0k6LV2/V5h3fqvjwcT01bYUiGoaqdfMGkqSY6Ob6652dNfCJufrtt5NOx55rrGmjUDVtdIlTe+KLI3tr3t8ztX3X2RdGBP7IZrOpZdSVevLZF7Tu448UXLu2fin82ek9R48c0UUXXeR4/f7yv2vL5s815unnS53vXGOoHLQuAmVD1qkc58s6kpT11fdKTp2vxK5tVDsosFzn/+nnQ/L19VH90GB3Tx3VxObPPtXiRW/puRdelN8ZecaV9NdmKOrKVrrhxi7nPW9IvXoq+uUX/frrr26aKc6GrAOUDVmnclQk6zT4Ux19vj1PB385IunUo6d2/CdfzRqFqujwMXW792X1G5WubbvytfObfXr7v4+3KstnAeUVElJPJ0+e1IGCn3RxcLDemJehCZOmqHmLK9Qkoqlu/e86ZB+s/Ie639JDrVq30cUXX6wHH3pYP3z/vXbl0vFVFcg7rpW5uNGsWTNNnDhRx48fdzk+b948HTt2TO3atTvrOVJSUlRUVOS0+YWd/f3VgY+PTZfUvdjx+uJaAaoZUEO+vj5qHF5P89IG6uEX3tHOb/Y5HXeuMUnqfdM1WrVxh1PRo2+PaD3Q90b9+M8J+vGfE9Tp6qZ6b+pgjRx0U+V9QVjWv7d8rqmTXnS8vsjvItlsNkVENNP2bf97Tmh+/g86ceJXBdeuLUnK+XKHXhr/nJ5/4SXVqxfqdM5zjaHycAEEyoasUznOlnWCLw7UuIdvd+w/ceI3lZRIJ89z59e4h2/XXbe0d7y+tnWEfv/9pH7Yz1piKL/8H37Q6MdG6m9PpKpps8vP+/7VK9/XhnVr1eX6DupyfQd9sPIfeuH5Z/TCc08rZdQj+uLf//sD37bsL1SvXqhq/KHjFe5H1gHKhqxTOSqSdfJ/+kWBAc7Xh8suDdHen/73uOcfC4qU2LWNxr6y3PH0jXP9DQkoq8kvTdCqf6xwvN6WnSUfHx+F1b/Use+SS/6ktR9/pIeGj5Cv76n1YEpKTurnn/93s+uRI0d0/Pgx/f579e7eqirkHdf8yvrGN954QwkJCXr77bfVsWNHRUREyN/fXwUFBfrkk0906NAhLVy4UH/605/Oeg5/f3/5+/s77bP5+FZ89gbYlLVbrz/zF32xM1Y/HTykgXdcp/0Hi/Wfb3/ShjdH6v3127V8bbZqBZ666B059qsC/C/Se1MHuxw77ebrozR/ufPdFi16jHV6Pf+FQXr1rfX6cFNOJX9LWNFljZto6XsPqtFljdXphs6a8eoUXXvd9ep0w416/ulUrfj7e4q/vZfmpr+m6Guvk6+vr37++aAeHf6ABgy8Vy2vvFJHj566C6VmzVrnHAMAb0DWqRxnyzp7fjig/+t1vb7+rkAfbvpSTz4YrzWffqVDR1z/weW0bbvy9eSDPbX/52L5+vho0mN/Vsb7n+vY8RNV9I1giuPHj+uRhwYrJrarYuO6ObJJYGDNs/7j7/W5C5z+Af/ySxPUqnUbxSfeoSWLF2nSiy9oxKjH9csvhZo2ZbJ639m3Sr4LAJQFWadyVCTrfLDxS03625+V3OcGrfrnDiXGtVGr5g3U/2+zHecd0jdGu/bs14r12877Wdv/wxM6UHbNm1+h6a9MUUi9UJ08+bsmpD2n2+ITFRj4vw7qt99aoCZNmio2rptjX9tr2mnsmBQteHOu6tWrp6XvLVG90FBFNm/hia8BSCpHceOqq67Szp07tXLlSm3btk3FxcXy8/PTlVdeqYEDB+rGG290VPJQdkvXfKEWEfU1tH+s6ocG68uvf9RdI15Xlw7NFdXsUkU1u1T39r7e8f4WPcaqdYsGZx377sefFeB/kaKvaqwHn13o9FlnLiwuScd//U37DhSr6PCxyv2SsKTQS/6kF158WZNeTNPUyRN07XU36KlnX5Cfn59GP/msxjw+UlNfflE+Nh/NSJ8nSfpw1T908MABvTZtql6bNtVxrs+/+OqcY6hcnizOP/bYY8rJydGKFafuCtmxY4cGDRqkr7/+WsnJyZowYYLjD0gbNmzQ4MGDVVBQoCeeeEIjRoxwnGfJkiV69NFHdeLECb300ktKSvrf4sHTpk3TM888o1q1aik9PV1du3at2i8JY5B1KsfZss4P+39Rv1Gz9eKo3kp75HatyfxKyanzz3u+RSs3K6rZpVo4MVm//16iRSs/19hXVpz3OOCPPs3cpG9279Y3u3dr6buLHfuXr1qj8AauH+8RVr++0+uaNWuqTt26qlO3rgYOStbe/B/00AP3q2atmupzV18NSv5rpX4HnGLojYiA25F1KkdFss7PRUd0x0MzlDbiDo0f0Uv7DhRpwGNv6If9v0iS6lwcqEfuuUmJD04r02f98VHlwLncFp+gb3b/R6NGDJOvj4969EzQ0GGPOMaLi4o0b066Xp2Z7nRc3E3dlffNN3prwZs6UFCgyyMj9dLLrzo9phyVh7zjmq3Ew6u+BLYd6smPBxz2fTL1/G+Cw4EDBdqZ86Wuat1GderU9fR0jFI70L0txZGjPrjgc/znxVvKfcy2bdt0/fXXKzs7W02bNpXdbtcVV1yh7t27a9SoURo2bJj69OmjQYMGqaCgQJdffrkeffRRJSUlqW/fvpo4caJiY2O1Y8cOtWvXTtOmTdO1116rXr166f3331eLFi20evVq3X777Vq0aJEuueQSDRgwQJs3b1a9evUu+DsD7kLWgbf46VOyDrzDxf5mZB0Ap5B14C0OfPaKp6cASJJq1XB/JYK84xoP5QNQIaGhl+iGG7tQ2LAAm+3Ct/I6efKk7r//fj3yyCNq2rSpJGnVqlUqKirSpEmT1KxZM40bN06zZ59qu87IyFB4eLhSU1MVGRmpsWPHOsbS09MVGxur5ORktWrVSkOHDtX8+afueJoxY4buueceJSYmqlOnTkpMTNTSpUvd84MDAACW4Imsc9pjjz2m+Ph4x+sdO3YoOjpadevW1ahRo3TmvYQbNmxQy5YtFRoaqkmTJjmdZ8mSJWrcuLHCw8O1cKFzB/60adMUFhampk2bau3atRWfLAAAsCxP5h1vRnEDAAznjkWn7Ha7iouLnTa73X7Wz5w5c6a2b9+uJk2aaPny5fr111+VnZ2tjh07qmbNmpKk1q1bKyfn1Jo/2dnZio2NdTyiqkOHDtq6datj7MxHTZV1DAAAVA+eWmBz27Ztmj59uqZMmSJJstvtio+PV7t27bRlyxbl5ORo7ty5kqSCggIlJCQoKSlJmZmZysjI0Lp16ySdKoj0799fqampWr16tcaOHavc3FxJ0urVqzVy5EjNmjVLCxYsUHJysg4ePHjhPzQAAGApLCjuGsUNAMB5paWlqXbt2k5bWlqay/cePnxYTz75pJo2bapvv/1WkydP1g033KDi4mJFREQ43mez2eTr66vCwsJSY8HBwdq7d68kVXgMAACgstClCgAAqgNv71KluAEAhnNH62JKSoqKioqctpSUFJef99577+nIkSNat26dnn76aX300Uc6dOiQ3njjDfn7+zu9NyAgQEePHpWfn5/T2On9kio8BgAAqgdPPKaBLlUAAFCVPJF3rNClSnEDAAzn42O74M3f31/BwcFO2x8LFaf98MMP6tixo0JDQyWdKkC0bt1av/zyiwoKCpzee+jQIdWoUUMhISFOY6f3S6rwGAAAqB7ckXXK8whOulQBAEBVc0feKQ+rdKlS3AAAw1V1db9hw4Y6duyY075vv/1WL7/8sjIzMx378vLyZLfbFRISoujoaKexrKwsNWjQQJIqPAYAAKoHd2Sd8jyCky5VAABQ1dyRd8pzM4dVulQpbgAA3Oq2225TTk6OZs6cqR9++EFTp05Vdna2evXqpeLiYs2ZM0eSNG7cOHXr1k2+vr5KSEjQpk2btGbNGp04cUITJkxQ9+7dJUm9e/fWokWLtH37dh0+fFhTp051jPXp00fTp09Xfn6+9u/fr9mzZzvGAAAAyqo8j+CkSxUAAFhRWW/msFKXql/Zvz4AwIpOV82rSr169bRy5UqNHDlSI0aM0KWXXqp33nlHjRo1Unp6upKSkjRq1Cj5+Pho/fr1kqTQ0FBNnjxZPXr0UFBQkOrUqeN4bmObNm00fPhwtW/fXgEBAYqMjNSQIUMkSfHx8Vq8eLEiIyMlSXFxcerVq1eVfl8AAOBZ7sg6/v7+Z33k5h+dq0v1lVdecez7Y5fqW2+95Rhz1Yl67733nnUsLi6u1BgAAKg+3JF3UlJSNGLECKd9rvLPmV2qoaGh+u2339SqVSu98cYbGjRokNN7Pd2lSucGABjOE4tOXX/99crMzNTRo0e1e/duxcfHS5ISEhK0e/duzZs3T1999ZWioqIcxwwePFi5ubnKyMjQtm3bFBYW5hh7/vnnlZWVpSVLluiTTz5RYGDgf7+bTfPnz9eGDRu0cuVKLV++vMqLOQAAwLOqOuvQpQoAAKqaO/JOWddTtVKXKp0bAGA4b/tjf/369XXbbbe5HIuIiHBqRzxTVFSUUzHkTNHR0W6bHwAAsBa6VAEAgOmqMu9YqUuVzg0AAAAAAMqBLlUAAGAqK3Wp0rkBAIbjH8AAAMBk3pZ16FIFAADuVpV5x0pdqhQ3AMBwXvbvfQAAALci6wAAANNVdd453aX6R6e7VLdu3aqOHTuqXr16jrHBgwere/fu2rlzpzp37qygoCDH2PPPP6/+/fsrPz9fMTExjnU1TnepDhs2TEeOHFFMTEy5CjkUNwDAcN52NyMAAIA7kXUAAIDpvCnveFOXKmtuAAAAAAAAAAAAS6FzAwAM50XFfQAAALcj6wAAANORd1yjuAEAhvOm1kUAAAB3I+sAAADTkXdco7gBAIbj+gcAAExG1gEAAKYj77jGmhsAAAAAAAAAAMBS6NwAAMPRuggAAExG1gEAAKYj77hGcQMADMf1DwAAmIysAwAATEfecY3iBgAYjuo+AAAwGVkHAACYjrzjGmtuAAAAAAAAAAAAS6FzAwAMR3EfAACYjKwDAABMR95xjeIGABiO1kUAAGAysg4AADAdecc1ihsAYDiufwAAwGRkHQAAYDryjmusuQEAAAAAAAAAACyFzg0AMBytiwAAwGRkHQAAYDryjmsUNwDAcFz/AACAycg6AADAdOQd1yhuAIDhqO4DAACTkXUAAIDpyDuuseYGAAAAAAAAAACwFDo3AMBwVPcBAIDJyDoAAMB05B3XKG4AgOG4/gEAAJORdQAAgOnIO65R3AAAw1HdBwAAJiPrAAAA05F3XGPNDQAAAAAAAAAAYCl0bgCA4SjuAwAAk5F1AACA6cg7rlHcAADD0boIAABMRtYBAACmI++4RnEDAAzH9Q8AAJiMrAMAAExH3nGNNTcAAAAAAAAAAIClUNwAAMP52GwXvJXHsGHDZLPZHNvll18uSdqxY4eio6NVt25djRo1SiUlJY5jNmzYoJYtWyo0NFSTJk1yOt+SJUvUuHFjhYeHa+HChU5j06ZNU1hYmJo2baq1a9dW8CcEAACsrKqzDgAAQFUj77hGcQMADGezXfhWHlu2bNE//vEPFRYWqrCwUFlZWbLb7YqPj1e7du20ZcsW5eTkaO7cuZKkgoICJSQkKCkpSZmZmcrIyNC6desknSqI9O/fX6mpqVq9erXGjh2r3NxcSdLq1as1cuRIzZo1SwsWLFBycrIOHjzozh8dAACwgKrOOgAAAFWNvOMaxQ0AMNyZXRQV3crqt99+05dffqkbb7xRderUUZ06dXTxxRdr1apVKioq0qRJk9SsWTONGzdOs2fPliRlZGQoPDxcqampioyM1NixYx1j6enpio2NVXJyslq1aqWhQ4dq/vz5kqQZM2bonnvuUWJiojp16qTExEQtXbrU/T9AAADg1aoy60h0qQIAgKpX1XnHKihuAADOy263q7i42Gmz2+2l3rd9+3adPHlSV199tQIDA3XLLbfou+++U3Z2tjp27KiaNWtKklq3bq2cnBxJUnZ2tmJjYx0X2g4dOmjr1q2Osa5duzrOX9YxAACAykKXKgAAMJmVbuSguAEAhvOxXfiWlpam2rVrO21paWmlPisnJ0ctWrTQ/PnztW3bNvn5+en+++9XcXGxIiIiHO+z2Wzy9fVVYWFhqbHg4GDt3btXkio8BgAAqg93ZJ2yoksVAAB4QlXmHSvdyEFxAwAM547WxZSUFBUVFTltKSkppT6rf//+2rJli6677jpFRkZq+vTp+uijj3Ty5En5+/s7vTcgIEBHjx6Vn5+f09jp/ZIqPAYAAKoPd2QdulQBAIA3q6rHUlntRg6KGwBgOHcsOuXv76/g4GCn7Y/FClf+9Kc/6eTJk6pfv74KCgqcxg4dOqQaNWooJCTEaez0fkkVHgMAANWHO7IOXaoAAMCbuSPvlIXVbuSguAEAcJtRo0bprbfecrzOzMyUj4+PWrVqpczMTMf+vLw82e12hYSEKDo62mksKytLDRo0kKQKjwEAAJQHXaoAAMB0ZelUtdqNHBQ3AMBwNjf8p6zatGmjMWPG6OOPP9aHH36owYMH6+6779bNN9+s4uJizZkzR5I0btw4devWTb6+vkpISNCmTZu0Zs0anThxQhMmTFD37t0lSb1799aiRYu0fft2HT58WFOnTnWM9enTR9OnT1d+fr7279+v2bNnO8YAAED14Y6sQ5cqAADwZu7IO2XpVLXajRwUNwDAcFW56NSAAQN01113qXfv3kpKStItt9yiV199VX5+fkpPT9fQoUMVGhqqZcuWafz48ZKk0NBQTZ48WT169FBYWJhyc3M1ZswYSaeKJcOHD1f79u3VoEED+fr6asiQIZKk+Ph4xcXFKTIyUhEREWrbtq169erl9p8fAADwblWZdehSBQAAnuCOvFPWTtUzefuNHBQ3AMBwVbXo1GlpaWn65ZdfdPDgQU2ZMkW1atWSJCUkJGj37t2aN2+evvrqK0VFRTmOGTx4sHJzc5WRkaFt27YpLCzMMfb8888rKytLS5Ys0SeffKLAwEDH95o/f742bNiglStXavny5eWeKwAAsL6qzDp0qQIAAE9wR94pS6eq1W7k8CvXuwEAuAD169fXbbfd5nIsIiLC6VmLZ4qKinIqhpwpOjrabfMDAAA4lwEDBujLL79U79695evrqwEDBmjcuHGOLtWkpCSNGjVKPj4+Wr9+vSTnLtWgoCDVqVNHc+fOleTcpRoQEKDIyEinLtXFixcrMjJSkhQXF0eXKgAAqFSnb+QICwvT77//roceeqjUjRyDBg0qdSPHgw8+qDVr1igmJqbUjRzXX3+9hg8froiICE2dOlUDBgyQdOpGjsGDB2vQoEHy8/PT7NmzNWXKlHLN11ZSUlLi9p9COQS2HerJjwcc9n0y1dNTACRJtQPd21R3e/qWCz7H35Pbu2EmQPVE1oG3+OlTsg68w8X+5madffv2aevWrerYsaPq1avnNJaXl6edO3eqc+fOCgoKchrLyclRfn6+YmJiSj2OYfPmzTpy5IhiYmLoUoVXIuvAWxz47BVPTwGQJNWq4f7rdVXmnZSUFM2YMcPpRo5atWpp+fLlSkpKUmBgoONGjtM3os6cOVPDhg1z3MiRmZnpeCrH6NGjNXHiRMeNHBs3blRgYKBKSkp09913691335V06kaO8j6Vg+IG8F8UN+At3F3c6DV76wWf471727lhJkD1RNaBt6C4AW/h7uIGWQfwLLIOvAXFDXiLyihueEve8bYbOXgsFQAYjhv8AACAycg6AADAdN6Sd7ztceMsKA4AAAAAAAAAACyFzg0AMBzPZgYAACYj6wAAANORd1yjuAEAhuP6BwAATEbWAQAApiPvuEZxAwAM58MVEAAAGIysAwAATEfecY01NwAAAAAAAAAAgKXQuQEAhqO2DwAATEbWAQAApiPvuEZxAwAMx6JTAADAZGQdAABgOvKOaxQ3AMBwPlz/AACAwcg6AADAdOQd11hzAwAAAAAAAAAAWAqdGwBgOFoXAQCAycg6AADAdOQd1yhuAIDhuP4BAACTkXUAAIDpyDuuUdwAAMNR3QcAACYj6wAAANORd1xjzQ0AAAAAAAAAAGApdG4AgOF8KO4DAACDkXUAAIDpyDuuUdwAAMPRuggAAExG1gEAAKYj77hGcQMADMflDwAAmIysAwAATEfecY3iBgAYzofqPgAAMBhZBwAAmI684xoLigMAAAAAAAAAAEuhcwMADEdxHwAAmIysAwAATEfecY3iBgAYjkWnAACAycg6AADAdOQd1yhuAIDhuP4BAACTkXUAAIDpyDuuseYGAAAAAAAAAACwFDo3AMBwPpT3AQCAwcg6AADAdOQd1yhuAIDhuP4BAACTkXUAAIDpyDuuUdwAAMOx6BQAADAZWQcAAJiOvOMaa24AAAAAAAAAAABL8XjnRuHmVz09BQAwmier2Lfccov69u2rgQMHasOGDRo8eLAKCgr0xBNPaMSIEY73LVmyRI8++qhOnDihl156SUlJSY6xadOm6ZlnnlGtWrWUnp6url27OsZGjx6t6dOnq1GjRlqwYIFat25dpd8PKAuyDgBULu7YAzyLrAMAlY+84xo/FwAwnM1mu+CtIjIyMrR69WpJUkFBgRISEpSUlKTMzExlZGRo3bp1kqQdO3aof//+Sk1N1erVqzV27Fjl5uZKklavXq2RI0dq1qxZWrBggZKTk3Xw4EFJ0muvvabXXntNy5cv13PPPae+ffvq119/dcNPDAAAWImnsg4AAEBVIe+4RnEDAAznY7vwrbx+/vlnPfroo2rRooWkU4WO8PBwpaamKjIyUmPHjtXs2bMlSenp6YqNjVVycrJatWqloUOHav78+ZKkGTNm6J577lFiYqI6deqkxMRELV261DE2cuRIde7cWQkJCWrRooX++c9/uueHBgAALMMTWee0W265RXPnzpUkbdiwQS1btlRoaKgmTZrk9L4lS5aocePGCg8P18KFC53Gpk2bprCwMDVt2lRr1651Ghs9erTq1q2r1q1ba9u2bRWfKAAAsDRP5h1vRnEDAHBedrtdxcXFTpvdbj/r+x999FHdcccd6tixoyQpOztbsbGxjjsFOnTooK1btzrGznzUVFnGSkpKtH379rMeBwAAUNnoUgUAAKbz9hs5KG4AgOHcUd1PS0tT7dq1nba0tDSXn7du3Tp9/PHHmjBhgmNfcXGxIiIiHK+Dg4O1d+/eCo8dPnxYJ0+ePOtxAACg+qBLFQAAmM4TeccKN3JQ3AAAw7njuYwpKSkqKipy2lJSUkp91vHjx/XXv/5VM2bM0MUXX+zY7+fnJ39/f8frgIAAHT16tMJjfn5+knTW4wAAQPXhjqxDlyoAAPBmVb3mhlVu5KC4AQCGc0d139/fX8HBwU7bmYWF05599llFR0frtttuc9ofEhKigoICx+tDhw6pRo0aFR4LDAxUYGDgWY8DAADVB12qAADAdO7IO+W5mcMqN3JQ3AAAuM1bb72lZcuWqU6dOqpTp47eeustDRkyRPPmzVNmZqbjfVlZWWrQoIEkKTo6ukJj7du3P+sYAABAedClCgAATFfWmzmsdCMHxQ0AMJzNduFbWW3cuFE7duzQF198oS+++EIJCQl65pln9N1332nTpk1as2aNTpw4oQkTJqh79+6SpN69e2vRokXavn27Dh8+rKlTpzrG+vTpo+nTpys/P1/79+/X7NmzncbGjx+v4uJi7dq1S0uWLHGMAQCA6sMdWYcuVQAA4M3ckXfKcjOH1W7k8CvXuwEAluNTzucqXoiGDRs6vQ4KClJoaKhCQ0M1efJk9ejRQ0FBQapTp47mzp0rSWrTpo2GDx+u9u3bKyAgQJGRkRoyZIgkKT4+XosXL1ZkZKQkKS4uTr169ZIk/fWvf9WyZcvUsGFD2e12JScnq127dlX2XQEAgHeoyqzz1ltvqaCgQHXq1JEkHT16VO+8844kqVOnTo73uepEvffee886FhcXV2rsdJdqs2bNHGOnn3sNAACqF3fkHX9/f5c3b5zJEzdyBAcHlzqurChuAIDhPNmid7qAIUmDBw9W9+7dtXPnTnXu3FlBQUGOseeff179+/dXfn6+YmJiHBczm82m+fPna9iwYTpy5IhiYmIcz3f09/fXRx99pE2bNsnf318dOnSo0u8GAAC8Q1VmnY0bN+q3335zvB45cqQ6duyogQMHqlGjRlqzZo1iYmJKdalef/31Gj58uCIiIjR16lQNGDBA0qlO1MGDB2vQoEHy8/PT7NmzNWXKFMfY+PHjlZCQoH379mnJkiXlXmQTAACYoaryjtVu5KC4AQCoMhEREU7PUzxTVFSUoqKiXI5FR0e73O/j46POnTu7bX4AAADnQpcqAAAwmdVu5LCVlJSUuOm7V8jx387/HgCoTgLcXHYevWrXBZ/j+Vubu2EmQPVE1gEAZyZnnby8PJddqpKUk5NTqkv1tM2bN5fqUpWkkydP0qUKr0fWAQBn7s46kufyzsCBA9WlSxcNHDhQM2fO1LBhwxw3cmRmZiosLOzU/EaP1sSJEx03cmzcuFGBgYEqKSnR3XffrXfffVfSqRs5li9fLpvNJrvdrh49emjz5s2OGzmmTZtWrvlR3AAAL+Pui2DqB/+54HM8e0ukG2YCVE9kHQBwRtYBzELWAQBnlVHc8Ja84203cvBYKgAwXBWusQkAAFDlyDoAAMB03pJ3vO1x455cZxYAAAAAAAAAAKDc6NwAAMP5eEl1HwAAoDKQdQAAgOnIO65R3AAAw/l4S+8iAABAJSDrAAAA05F3XKO4AQCG4/oHAABMRtYBAACmI++4xpobAAAAAAAAAADAUujcAADD8VxGAABgMrIOAAAwHXnHNYobAGA4m7gCAgAAc5F1AACA6cg7rlHcAADDUd0HAAAmI+sAAADTkXdcY80NAAAAAAAAAABgKXRuAIDhqO4DAACTkXUAAIDpyDuuUdwAAMPZbFwBAQCAucg6AADAdOQd1yhuAIDhqO4DAACTkXUAAIDpyDuuseYGAAAAAAAAAACwFDo3AMBwdC4CAACTkXUAAIDpyDuuUdwAAMP5cAUEAAAGI+sAAADTkXdco7gBAIbjuYwAAMBkZB0AAGA68o5rrLkBAAAAAAAAAAAshc4NADAcnYsAAMBkZB0AAGA68o5rFDcAwHA+4goIAADMRdYBAACmI++4RnEDAAxHdR8AAJiMrAMAAExH3nGNNTcAAAAAAAAAAICl0LkBAIbzoboPAAAMRtYBAACmI++4RnEDAAznQ+8iAAAwGFkHAACYjrzjGsUNADAc1z8AAGAysg4AADAdecc11twAAAAAAAAAAACWQucGABjOU62Lv/zyi3Jzc9W8eXPVrVvXI3MAAADm4zENAADAdOQd1+jcAADD2WwXvpXX4sWL1aRJEyUnJ6thw4ZavHixJGnHjh2Kjo5W3bp1NWrUKJWUlDiO2bBhg1q2bKnQ0FBNmjTJ6XxLlixR48aNFR4eroULFzqNTZs2TWFhYWratKnWrl1b/skCAABL80TWAQAAqErkHdcobgCA4XzcsJVHUVGRhgwZon/+85/avn27pk2bplGjRslutys+Pl7t2rXTli1blJOTo7lz50qSCgoKlJCQoKSkJGVmZiojI0Pr1q2TdKog0r9/f6Wmpmr16tUaO3ascnNzJUmrV6/WyJEjNWvWLC1YsEDJyck6ePDgBfy0AACA1VR11jntl19+0WeffabCwsILmj8AAMD5eCrveDtTvxcAwEOKi4v18ssvq3Xr1pKka665RgcPHtSqVatUVFSkSZMmqVmzZho3bpxmz54tScrIyFB4eLhSU1MVGRmpsWPHOsbS09MVGxur5ORktWrVSkOHDtX8+fMlSTNmzNA999yjxMREderUSYmJiVq6dKlnvjgAAKg26FIFAACms8KNHBQ3AMBwNpvtgrfyaNSokfr37y9JOnHihCZPnqw77rhD2dnZ6tixo2rWrClJat26tXJyciRJ2dnZio2NdXxWhw4dtHXrVsdY165dHecv6xgAAKgeqjrr0KUKAACqWlXnHavcyEFxAwAMZ3PDZrfbVVxc7LTZ7fZzfm52drbq16+vDz74QFOnTlVxcbEiIiL+Ny+bTb6+viosLCw1FhwcrL1790pShccAAED14I6sUx50qQIAgKpWlXnHSjdyUNwAAMP52GwXvKWlpal27dpOW1pa2jk/t3Xr1vrwww8VGRmp5ORk+fn5yd/f3+k9AQEBOnr0aKmx0/slVXgMAABUD+7IOuW5kYMuVQAAUNXckXfKyko3clDcAACcV0pKioqKipy2lJSUcx5js9nUrl07zZs3T++9955CQkJUUFDg9J5Dhw6pRo0apcZO75dU4TEAAICyqsiNHHSpAgAAKynrzRxWupGD4gYAGM4drYv+/v4KDg522v7YhXHahg0bNGrUKMfrGjVqyGazqWXLlsrMzHTsz8vLk91uV0hIiKKjo53GsrKy1KBBA0mq8BgAAKge3JF1KnIjB12qAACgqrgj75T3Zg4r3MhBcQMADGezXfhWHs2bN9esWbM0a9Ysff/993riiSd08803q0ePHiouLtacOXMkSePGjVO3bt3k6+urhIQEbdq0SWvWrNGJEyc0YcIEde/eXZLUu3dvLVq0SNu3b9fhw4c1depUx1ifPn00ffp05efna//+/Zo9e7ZjDAAAVA/uyDrluZHjf59LlyoAAKga7sg75b2Zwwo3clDcAADD2Wy2C97K49JLL9WSJUs0ZcoUXXnllTp69KjefPNN+fn5KT09XUOHDlVoaKiWLVum8ePHS5JCQ0M1efJk9ejRQ2FhYcrNzdWYMWMkSW3atNHw4cPVvn17NWjQQL6+vhoyZIgkKT4+XnFxcYqMjFRERITatm2rXr16ufcHCAAAvFpVZx26VAEAQFVzR94p780cVriRg+IGAMDtbrrpJn355ZcqLi7W4sWLdckll0iSEhIStHv3bs2bN09fffWVoqKiHMcMHjxYubm5ysjI0LZt2xQWFuYYe/7555WVlaUlS5bok08+UWBgoKRTF9r58+drw4YNWrlypZYvX17uP1AAAACUB12qAADAZFa6kcNWUlJSUv6v6D7Hf/PkpwOA9wnwc+/53s7Kv+Bz3NWWOwSBiiLrAIAzE7LORx99pIcffljff/+9unfvrunTp+uSSy7R8uXLlZSUpMDAQPn4+Gj9+vWOmzlmzpypYcOGKSgoSHXq1FFmZqbjZo7Ro0dr4sSJCggIUGRkpDZu3KjAwECVlJTo7rvv1rvvvitJiouL42YOeB2yDgA4c3fWkao27/z444+64oor9OKLL+rWW2/VmDFj9NNPP2nFihUKDw/X+PHjNWjQIN13333at2+fVqxYoQMHDqhRo0ZasWKFYmJilJCQoMsvv1yvvPKKsrOzdf311yszM1MRERHq3LmzBgwYoEcffVTLly/X4MGDtXnzZvn5+aldu3aaMmWKevfuXaa5UtwAAC/j7ovgO1+UfSGms7nz6nA3zASonsg6AODM9Kyzb98+bd26VR07dlS9evWcxvLy8rRz50517txZQUFBTmM5OTnKz89XTExMqccxbN68WUeOHFFMTAyFDXgdsg4AOKuM4kZV5x2r3MhBcQMAvIy7L4KL3XAB/DPFDaDCyDoA4IysA5iFrAMAziqjuOFNecebbuSohB81AAAAAAAAAAAwTf369XXbbbe5HIuIiFBERITLsaioKKe1V88UHR1doblQ3AAAw/HoAgAAYDKyDgAAMB15xzWKGwBgOB9PTwAAAKASkXUAAIDpyDuuUdwAAMNR3QcAACYj6wAAANORd1yjuAEAhuPyBwAATEbWAQAApiPvuEZHCwAAAAAAAAAAsBQ6NwDAcHQuAgAAk5F1AACA6cg7rlHcAADD+dC8CAAADEbWAQAApiPvuEZxAwAMR3UfAACYjKwDAABMR95xjTU3AAAAAAAAAACApdC5AQCGs9G6CAAADEbWAQAApiPvuEZxAwAMR+siAAAwGVkHAACYjrzjGsUNADAci04BAACTkXUAAIDpyDuuseYGAAAAAAAAAACwFDo3AMBwtC4CAACTkXUAAIDpyDuuUdwAAMNxAQQAACYj6wAAANORd1yjuAEAhrPxXEYAAGAwsg4AADAdecc11twAAAAAAAAAAACWQucGABjOh+I+AAAwGFkHAACYjrzjGsUNADAcrYsAAMBkZB0AAGA68o5rFDcAwHAsOgUAAExG1gEAAKYj77jGmhsAAAAAAAAAAMBS6NwAAMPRuggAAExG1gEAAKYj77hG5waAC1ZcXKxt27JVXFTk6anABR/bhW8AAFRnZB3vRtYBAODCkHW8H3nHNYobFlNY+LNuvbmr8vN/KNN+wJ1c/Z59uHqVetzcVU+PHaOb4mL04epVpY6b/NKLemjI4KqcKs5gc8N/AKAqubrerFu7Rj26x+ma1lG6s1eivtm924MzhKnKm3VeGPec2lzZwrH1vOUmT0y72iPrALAasg48haxjXeQd13gslYUUFv6sh4YM1t78/DLtB9zJ1e/ZoUOHNO7Zp/XGvAVq3uIKLVv6niZPfFE3d7/V8Z5duTv1zqK3tPi95Z6YNgDAYlxdb77/7juNHf2Exjz5lNq376AXxj2rp8eO1ryMRR6cKUxTkayT8+UOvTpjltpc3VaS5OvLvWMAgHMj68BTyDowEb+RFvLYyBG69baeZd4PuJOr37Mjhw9r1ONPqHmLKyRJLaOi9MsvhY7xkydP6pmnxmrA3QPVsFGjKp0v/sdmu/ANAKqKq+vNN9/s1vBHHlX3W3qoXmio/nxXknbu/MpDM4Spypt1fvvtN+3++j9q1669goODFRwcrFq1gqp83iDrALAWsg48haxjbeQd1yhuWMjYp59V/wF3l3k/4E6ufs/qX3qpbuuZIEk6ceKE5r85T127/a9FcfHbC/Wf/+xSeIMGWr/2Y5349dcqnTNOsblhA4Cq4up6E9MlVn3uvMvxes+ePF12WeOqnhoMV96s85//7NLJkyd1Z+/b1eGa1nrg/nv14969VT5vkHUAWAtZB55C1rE28o5rFDcspGFD13e+n20/4E7n+j3L3blTcTE36JN/bdRjKWMkSUePHNGMaa+oYcNG+nHvXs1/c67u+Us/HT9+vKqmjP/ysdkueCuvZcuWqWnTpvLz89PVV1+tr746ddfRjh07FB0drbp162rUqFEqKSlxHLNhwwa1bNlSoaGhmjRpktP5lixZosaNGys8PFwLFy50Gps2bZrCwsLUtGlTrV27tgI/IQDe5Hy55sSvv2r+3Dn68119q2hGqC7Km3W+2f21mkRE6PkXJmjx0uXy9fPTM0+lVtV0cQZPZB0AqCiyDjyFrGNt5B3XqrS4YbfbVVxc7LTZ7faqnAKAStC8RQvNfH22LmvcWE+PPXUR/HjNRzp27JjS58zTkKHD9Fr6HB09ekTvL1/m4dmisu3evVuDBg3SCy+8oPz8fDVv3lzJycmy2+2Kj49Xu3bttGXLFuXk5Gju3LmSpIKCAiUkJCgpKUmZmZnKyMjQunXrJJ0qiPTv31+pqalavXq1xo4dq9zcXEnS6tWrNXLkSM2aNUsLFixQcnKyDh486KmvDpB1qsD0aa8oMDBQd/T+s6engmrEVda5rWeCFr7zntpc3VaNGzfR6DFP6tPMT3T48GEPzxZVgRs5UF2RdSofWQeeQNbBH1kl65S5uPHdd9+VaTuXtLQ01a5d22l7cXxauSYMwPvYbDZFXXmVnh33gj5e86GKi4u1f/8+tWrdRnXrhkiS/Pz8FNm8hb7/7lsPz7b6qerWxa+++kovvPCC7rzzToWFhemBBx5QVlaWVq1apaKiIk2aNEnNmjXTuHHjNHv2bElSRkaGwsPDlZqaqsjISI0dO9Yxlp6ertjYWCUnJ6tVq1YaOnSo5s+fL0maMWOG7rnnHiUmJqpTp05KTEzU0qVLL+THhWqMrOP9Pvs0U28vzFDahJd00UUXeXo6qEZcZZ0/CqlXTydPntSBgp88MMPqraqzDjdywKrIOt6PrANPIet4v6rMO1bKOn5lfWOXLl307ben/ih5ZkXmTDabTb///vtZz5GSkqIRI0Y47Svx9S/rFAB4mS2bP9c/N6zTiJGPSZIuuqiGbDabfHx8FBZWv9QdPD/u3aurr27rialWb27oPLTb7aX++/T395e/f+n/De/Z03mBstzcXEVGRio7O1sdO3ZUzZo1JUmtW7dWTk6OJCk7O1uxsbGy/bdNskOHDnr88ccdY7feeqvjfB06dNAzzzzjGOvXr5/T2D//+U8lJydf6FdGNUTW8W4//PC9Hv/bo0oZM1bNLr/c09NBNXGurDNp4nhdcUWUevSMlyRlf5F1KgPVv9STU66eqvgpC2feyCFJDzzwgG677TanGzlq1qypcePG6cEHH9SgQYOcbuSw2WyOGzliY2OdbuSQ5LiR47nnnnO6kUOS40YOsg4qgqzj3cg68ASyjoVUYd6xUtYpc+fG559/rg4dOmjKlCk6efKky+1cF0Dp1B/CgoODnTZXfxgDYA2NmzTRu4vf0ZJ33ta+H3/UKy9P0nWdrldQUJA6x8Tom91f6523F2r/vn3KWPCmduXuVFy3mz097WrH5ob/uLpDKy3t/Hdo/frrr3rppZc0ePBgFRcXKyIi4n/zstnk6+urwsLCUmPBwcHa+9+Fyio6BpQXWcd7HT9+XA8NGazY2DjFxd2ko0eO6OiRI2f9wwzgLufKOs1bXKFXX3lZn32aqU82/UvPPfOkeibcrsDAQE9Pu9pxR9Ypz6N2evbsqfvvv9/xuqI3cmzdutUx1rVrV8f5yjoGlBdZx3uRdeApZB3rqMq8Y6WsU+biRmhoqFasWKFly5Y5Kv0AqrdLLvmTJk6eqowFb6pX4m06fvyYnkubIEmqU6euXp0xSyuW/V0Jt3XXWwve1ISXXlb9S6nwW1FKSoqKioqctpSUlPMe9+STT6pWrVpKTk6Wn59fqX/4BAQE6OjRo6XGTu+XVOExoLzIOt4r85N/6ZvdX+vdJe/oug7XOLa9e/M9PTUY7lxZp2d8orrf0kOPPvyQHh/1qK6/obNSRrPIplVxIweqA7KO9yLrwFPIOtVLRfKOt2edMj+WSjp1Ifzoo4/KcwgqQfaXueXaD7jTH3/Prut0vZYu/4fL97a9pp3mv/V2VUwL52BzQ+vi2R5BdS5r167VtGnT9Omnn+qiiy5SSEiIduzY4fSeQ4cOqUaNGgoJCVFBQUGp/ZIqPAZUBFnHe5x5vYnt2o2cgypTnqwz/JFHNfyRR6tiWjgHd2QdV4/aKUv2OfNGjjFjxnAjB7weWcd7kHXgKWQda/JU3vH2rFPmzg0AgDVV9SKbkpSXl6ekpCRNmzZNUVFRkqTo6GhlZmY6vcdutyskJKTUWFZWlho0aODyuLKOAQCA6sEdWacij9o5fSPHW2+95biR48ybLiRu5AAAAO7hibxjhaxDcQMATFfF1Y1jx46pZ8+eSkxM1B133KHDhw/r8OHD6ty5s4qLizVnzhxJ0rhx49StWzf5+voqISFBmzZt0po1a3TixAlNmDBB3bt3lyT17t1bixYt0vbt23X48GFNnTrVMdanTx9Nnz5d+fn52r9/v2bPnu0YAwAA1YQH7uTgRg4AAFClqjjvWCXrUNwAALjVhx9+qJycHL3++uu6+OKLHVt+fr7S09M1dOhQhYaGatmyZRo/frykU+3xkydPVo8ePRQWFqbc3FyNGTNGktSmTRsNHz5c7du3V4MGDeTr66shQ4ZIkuLj4xUXF6fIyEhFRESobdu26tWrl8e+OwAAMB83cgAAAJNZKevYSkpKStz/Iyi747958tMBwPsElGs1pPPbkld8wedoHxHshpmcsm/fPm3dulUdO3ZUvXr1nMby8vK0c+dOde7cWUFBQU5jOTk5ys/PV0xMTKkWxc2bN+vIkSOKiYmRzR0PogTciKwDAM6snnWWLVum22+/vdT+vLw8bdu2TUlJSQoMDJSPj4/Wr1/vuNtx5syZGjZsmIKCglSnTh1lZmYqLCxMkjR69GhNnDhRAQEBioyM1MaNGxUYGKiSkhLdfffdevfddyVJcXFxWr58OXkHXoWsAwDO3J11pKrNO1bKOhQ3AMDLuPsiuHXPhV8A2zVxX3EDqG7IOgDgzPSsw40cqG7IOgDgrDKKG96Ud7wp61DcAAAv4+6L4L/dcAG8huIGUGFkHQBwRtYBzELWAQBnlVHcIO+4xpobAAAAAAAAAADAUiqhjgQA8Co8uQAAAJiMrAMAAExH3nGJ4gYAGM7GFRAAABiMrAMAAExH3nGN4gYAGI41JwEAgMnIOgAAwHTkHddYcwMAAAAAAAAAAFgKnRsAYDiK+wAAwGRkHQAAYDryjmsUNwDAdFwBAQCAycg6AADAdOQdlyhuAIDhWHQKAACYjKwDAABMR95xjTU3AAAAAAAAAACApdC5AQCGs1HcBwAABiPrAAAA05F3XKO4AQCG4/oHAABMRtYBAACmI++4RnEDAEzHFRAAAJiMrAMAAExH3nGJNTcAAAAAAAAAAICl0LkBAIazUd4HAAAGI+sAAADTkXdco7gBAIZj0SkAAGAysg4AADAdecc1ihsAYDiufwAAwGRkHQAAYDryjmusuQEAAAAAAAAAACyFzg0AMB3lfQAAYDKyDgAAMB15xyWKGwBgOBadAgAAJiPrAAAA05F3XKO4AQCGY9EpAABgMrIOAAAwHXnHNdbcAAAAAAAAAAAAlkLnBgAYjuI+AAAwGVkHAACYjrzjGsUNADAdV0AAAGAysg4AADAdecclihsAYDgWnQIAACYj6wAAANORd1xjzQ0AAAAAAAAAAGApdG4AgOFsFPcBAIDByDoAAMB05B3XKG4AgOG4/gEAAJORdQAAgOnIO65R3AAA03EFBAAAJiPrAAAA05F3XGLNDQCA2x04cEARERHas2ePY9+OHTsUHR2tunXratSoUSopKXGMbdiwQS1btlRoaKgmTZrkdK4lS5aocePGCg8P18KFC53Gpk2bprCwMDVt2lRr166t1O8EAABwGlkHAADA8yhuAIDhbG74T3kcOHBAPXv2dPrHvt1uV3x8vNq1a6ctW7YoJydHc+fOlSQVFBQoISFBSUlJyszMVEZGhtatWyfp1B8J+vfvr9TUVK1evVpjx45Vbm6uJGn16tUaOXKkZs2apQULFig5OVkHDx50y88MAABYB1kHAACYzhN5xwo3clDcAADD2WwXvpVH37591a9fP6d9q1atUlFRkSZNmqRmzZpp3Lhxmj17tiQpIyND4eHhSk1NVWRkpMaOHesYS09PV2xsrJKTk9WqVSsNHTpU8+fPlyTNmDFD99xzjxITE9WpUyclJiZq6dKlF/4DAwAAlkLWAQAApqvKvGOlGzkobgCA4Wxu2Ox2u4qLi502u93u8vNef/11DRs2zGlfdna2OnbsqJo1a0qSWrdurZycHMdYbGysbP+90nbo0EFbt251jHXt2tVxnrKOAQCA6sMdWac8yDoAAKCqVWXesdKNHBQ3AMB0brgCpqWlqXbt2k5bWlqay4+LiIgota+4uNhpv81mk6+vrwoLC0uNBQcHa+/evS6PK+sYAACoRtyQdcpzIwdZBwAAVLkqzDtWupGD4gYA4LxSUlJUVFTktKWkpJT5eD8/P/n7+zvtCwgI0NGjR0uNnd7v6riyjgEAAJRHeW7kcIWsAwAAvF1Z846VbuTwK9e7AQCWU95Fo1zx9/cv9Q/28ggJCdGOHTuc9h06dEg1atRQSEiICgoKSu0/fVxFxgAAQPXhjqyTkpKiESNGOO0rT/Yh6wAAgMrk6bzjrTdy0LkBAIar6kU2XYmOjlZmZqbjdV5enux2u0JCQkqNZWVlqUGDBi6PK+sYAACoPtyRdfz9/RUcHOy0lae4QdYBAACVydN55483XUjecSMHxQ0AMJwbHst4wW688UYVFxdrzpw5kqRx48apW7du8vX1VUJCgjZt2qQ1a9boxIkTmjBhgrp37y5J6t27txYtWqTt27fr8OHDmjp1qmOsT58+mj59uvLz87V//37Nnj3bMQYAAKoPsg4AADCdp/OOt97IQXEDAFDp/Pz8lJ6erqFDhyo0NFTLli3T+PHjJUmhoaGaPHmyevToobCwMOXm5mrMmDGSpDZt2mj48OFq3769GjRoIF9fXw0ZMkSSFB8fr7i4OEVGRioiIkJt27ZVr169PPYdAQBA9UXWAQAAJvPWGzlsJSUlJe79quVz/DdPfjoAeJ8AN6+G9EOh/YLP0bBuxdfbONO+ffu0detWdezYUfXq1XMay8vL086dO9W5c2cFBQU5jeXk5Cg/P18xMTGlWhQ3b96sI0eOKCYmRjZ3PEMLcDOyDgA4I+uQdWAWsg4AOHN31pE8k3dsNpvy8vLUpEkTSdLy5cuVlJSkwMBA+fj4aP369YqKipIkzZw5U8OGDVNQUJDq1KmjzMxMhYWFSZJGjx6tiRMnKiAgQJGRkdq4caMCAwNVUlKiu+++W++++64kKS4uTsuXLy9X3qG4AQBexv3/4P/1gs/RsC6LVwIVRdYBAGdkHcAsZB0AcFY5xQ3vyDvediMHxQ0A8DLuvgjm/3LhF8AGdfgHP1BRZB0AcEbWAcxC1gEAZ5VR3CDvuMaaGwAAAAAAAAAAwFIqoY4EAPAmPJkZAACYjKwDAABMR95xjeIGABiOdScBAIDJyDoAAMB05B3XKG4AgOFs1PcBAIDByDoAAMB05B3XWHMDAAAAAAAAAABYCp0bAGA6ivsAAMBkZB0AAGA68o5LFDcAwHBc/wAAgMnIOgAAwHTkHdcobgCA4Vh0CgAAmIysAwAATEfecY01NwAAAAAAAAAAgKXQuQEAhrPRvAgAAAxG1gEAAKYj77hGcQMATMf1DwAAmIysAwAATEfecYniBgAYjusfAAAwGVkHAACYjrzjGmtuAAAAAAAAAAAAS6FzAwAMZ6O8DwAADEbWAQAApiPvuEZxAwAMx6JTAADAZGQdAABgOvKOaxQ3AMBwVPcBAIDJyDoAAMB05B3XWHMDAAAAAAAAAABYCsUNAAAAAAAAAABgKTyWCgAMR+siAAAwGVkHAACYjrzjGsUNADAci04BAACTkXUAAIDpyDuu8VgqAAAAAAAAAABgKXRuAIDhaF0EAAAmI+sAAADTkXdco7gBAIbj+gcAAExG1gEAAKYj77hGcQMATMcVEAAAmIysAwAATEfecYk1NwAAAAAAAAAAgKXQuQEAhrNR3gcAAAYj6wAAANORd1yjuAEAhmPRKQAAYDKyDgAAMB15xzWKGwBgOK5/AADAZGQdAABgOvKOa6y5AQAAAAAAAAAALIXODQAwHeV9AABgMrIOAAAwHXnHJYobAGA4Fp0CAAAmI+sAAADTkXdco7gBAIZj0SkAAGAysg4AADAdecc11twAAAAAAAAAAACWYispKSnx9CRQcXa7XWlpaUpJSZG/v7+np4NqjN9FAEBl4PoCb8LvIwDA3bi2wJvw+wirobhhccXFxapdu7aKiooUHBzs6emgGuN3EQBQGbi+wJvw+wgAcDeuLfAm/D7CangsFQAAAAAAAAAAsBSKGwAAAAAAAAAAwFIobgAAAAAAAAAAAEuhuGFx/v7+evLJJ1nkBx7H7yIAoDJwfYE34fcRAOBuXFvgTfh9hNWwoDgAAAAAAAAAALAUOjcAAAAAAAAAAIClUNwAAAAAAAAAAACWQnEDgFscOHBAERER2rNnj6enAgAA4HZkHQAAYDKyDqyI4oaF7dixQ9HR0apbt65GjRollk+Bpxw4cEA9e/bkAggAcCuyDrwFWQcAUBnIOvAWZB1YFcUNi7Lb7YqPj1e7du20ZcsW5eTkaO7cuZ6eFqqpvn37ql+/fp6eBgDAIGQdeBOyDgDA3cg68CZkHViVrYSysCX9/e9/1//93//phx9+UM2aNZWdna0HH3xQ//rXvzw9NVRDeXl5ioiIkM1mU15enpo0aeLpKQEALI6sA29C1gEAuBtZB96ErAOronPDorKzs9WxY0fVrFlTktS6dWvl5OR4eFaoriIiIjw9BQCAYcg68CZkHQCAu5F14E3IOrAqihsWVVxc7PQ/PDabTb6+viosLPTgrAAAANyDrAMAAExG1gGAC0dxw6L8/Pzk7+/vtC8gIEBHjx710IwAAADch6wDAABMRtYBgAtHccOiQkJCVFBQ4LTv0KFDqlGjhodmBAAA4D5kHQAAYDKyDgBcOIobFhUdHa3MzEzH67y8PNntdoWEhHhwVgAAAO5B1gEAACYj6wDAhaO4YVE33nijiouLNWfOHEnSuHHj1K1bN/n6+np4ZgAAABeOrAMAAExG1gGAC2crKSkp8fQkUDHLly9XUlKSAgMD5ePjo/Xr1ysqKsrT0wIAAHALsg4AADAZWQcALgzFDYvbt2+ftm7dqo4dO6pevXqeng4AAIBbkXUAAIDJyDoAUHEUNwAAAAAAAAAAgKWw5gYAAAAAAAAAALAUihsAAAAAAAAAAMBSKG4AAAAAAAAAAABLobgBAAAAAAAAAAAsheIGAAAAAAAAAACwFIobAAAAAAAAAADAUihuAAAAAAAAAAAAS6G4AQAAAAAAAAAALIXiBgAAAAAAAAAAsBSKGwAAAAAAAAAAwFIobgAAAAAAAAAAAEuhuAEAAAAAAAAAACyF4gYAAAAAAAAAALAUihsAAAAAAAAAAMBSKG4AAAAAAAAAAABLobgBAAAAAAAAAAAsheIGAAAAAAAAAACwFIobAAAAAAAAAADAUihuAAAAAAAAAAAAS6G4AQAAAAAAAAAALIXiBgAAAAAAAAAAsBSKGwAAAAAAAAAAwFIobgAAAAAAAAAAAEuhuAEAAAAAAAAAACyF4gbgRsXFxZ6eAgAAQKUh6wAAAJORdQBrobhRza1fv142m83l9tRTT0mSunTp4vj/PWXgwIEaOHCgW841d+5cNWnSxO2fu2fPHrVp00Y5OTkVn1wZvfPOO2revLnq1q2r+++/X8ePHy/zsU899dR5/zsHAMAUZB33fa5Vso4kZWVl6brrrlOtWrUUHh6ukSNH6sSJE5U0WwAAPIes477PtVLW+fTTT3XTTTepZs2aaty4sV566SWVlJRU0mwB70Vxo5pr166dNm/erM2bN6tnz55q3ry54/X999/v6elZSpMmTTRz5kzdeuutysrKqrTPWbNmjZKSknTzzTdr0aJF2rZtmx555JEyH3///fc7/js+vX3wwQfy9fXVNddcU2nzBgDAE8g67mOVrHP06FH16tVLV199tVatWqVnnnlG6enpSklJqbQ5AwDgKWQd97FK1tm2bZu6dOmiiIgIffTRRxo5cqRGjx6t1NTUSpsz4K38PD0BeNbFF1+s9u3bS5Lq1aunwMBAx2uUX/fu3ZWRkaHb/7+9ew+rqsr/OP45gAJKqEhhoOlR0bQ0FTGzkBQnSwXyMiXZlM1QmePolDrFqHQdScc0NS95SUtNM83E6WKZl8yYUsdIY8QuWIlpSATiBTX4/eF4fp08KpfDuSzeL5/9B3uds8/a5+Fxf9jftfa6/XYtX75c3bp1c/pnpKamqnfv3nrhhRckSS1atFCbNm30xBNPKCws7JLvDw8PV3h4uN2+xx57TJ06dVJCQoLT+wsAgDuRdZzLG7JORkaG8vPzNXPmTPn5+al79+7av3+/li9frilTpji9vwAAuBNZx7m8Ies8++yzateunebNmydJuvHGG/Xjjz9q6tSpevzxx1WrVi2n9xnwVMzcAJzspptu0po1azRkyBBt3LjRtn///v0XnCpqsVi0efPmSx67uLhYn3zyiYYMGWLb17JlS7Vp08busyoiLy9PL7zwgp555plKvR8AANQsnp51jhw5ct5jGU6dOqXAwMDynSAAAKjRPD3r7NixQ7169bLbd/XVV+v48ePKy8sr30kChqC4gXJ76aWX1KxZMwUHB+uuu+6yex7guWcYHjhwQElJSQoNDdW3335raz958qT++te/KiwsTA0aNNCdd9553n+4kyZNUrNmzVSnTh1FRUU5vCisW7dObdq0Ud26dXXbbbfpyJEjtrYffvhBd9xxh4KCghQWFqbHHntMZ86cqdA5vvzyy2ratKnq1Kmj++67T6dOnarQ+8/p1KmT3n77bT3wwAP617/+JensjIldu3ZdcCvPyIpDhw6ptLRU7du3t9vfvHlzffnll5Xq65w5c9SyZUvdcsstlXo/AACmIOuUnydnnW7duunMmTNKTU3V0aNH9e9//1uLFi3SH/7wh4qfKAAABiHrlJ8nZx1fX1/l5+fb7duzZ49q1aqlyy+/vJxnCJiBx1KhXN58800dP35c06ZNU35+vh566CF169ZNI0aMsL3mp59+0o033qjY2Fg98cQTCgkJsbU99NBDev/99/XCCy+obt26GjNmjAYMGKCtW7fajv/YY49p6tSp6tChg5YuXarbb79dhw8flr+/v6SzlekNGzbo2WefVe3atXX//ffr2Wef1ZQpU3TixAnFxcXJx8dHK1as0OHDhzVmzBgdOXJECxYsKNc5ZmRkaOjQoRo+fLgGDBigF1980Vapr4w2bdro/fff16233qrjx4/rjjvuUIcOHSp1rHNOnDghSapfv77d/qCgoEpV50+fPq0XX3zR7QuLAQDgbmSdivPUrNOkSRPNnz9ff/jDH5SWliZJuvPOOzV27Ngq9Q0AAG9G1qk4T806sbGxeuWVV3TPPffopptu0ieffKIXXnhBffv25ZFUqHEobqBc9u3bp3379qlx48aSpDVr1igzM9PuNevWrdPzzz+vUaNG2e3fv3+/Xn75Za1evVr9+/eXJJ05c0aJiYnKycmR1WpVTk6OatWqpQceeEB169ZVp06d1L9/f/3yyy+242RlZenTTz+1VcK3bNli68OKFSuUnZ2tvXv3KjIyUpLk4+OjP/3pTxo/fryaNWt2yXOcPn26rrnmGs2aNUvS2WmI5XnfxRQUFOjMmTMKDQ21nfeF+Pr6ymKxXPR45wKBr6+v3X6LxWK7QFbEm2++qeLi4kpf6AEAMAVZp3I8Met8++23+utf/6qhQ4eqT58++uKLLzR58mQ99thjmjx5crmOAQCAacg6leOJWeeJJ57QRx99pJiYGDVo0EAFBQWSZFeoAmoKHkuFcrn99tttF0BJuvzyy3X69Gm711xzzTX6y1/+ct57d+/erbKyMg0YMMD2HMLExERJsk25GzhwoBo0aKBrr71W999/v9544w3FxsaqTp06tuN07drVborfr/uwY8cONWnSxHYBlKRevXqprKxMO3bsKNc57tu3T126dLH97O/vr+uvv75c73Vk8+bNGjRokJYvX66ePXtq//79qlWr1gW3LVu2XPKYV1xxhSTpwIEDdvvz8/NVt27dCvdx2bJlSkhIsPueAQCoicg6FeepWee5557TDTfcoEWLFun3v/+9nnjiCc2cOVPPPfecfvjhh4qfKAAABiDrVJynZp1GjRrps88+09tvv63nnntOdevWVffu3RUXF1fxkwS8HDM3UC4tWrS45Gs6d+4sH58L18veffddhYWF2e1r3ry5JOmqq67Svn379O677+qjjz7SuHHj9PTTT+uzzz5TcHDwJfvw20Ujy9v2a6WlpedVzn/7c3mtWbNGY8aM0b/+9S+1bdtW0v8/m/FCWrZsecnj1q9fX1dddZU++ugj2wW7rKxM//nPfxQbG1uhPhYVFendd9/VihUrKvQ+AABMRNapGE/OOvv27VPHjh3t9nXo0EGlpaXav3+/rrzyynIdBwAAk5B1KsaTs44k+fn56bbbbtPKlSt17NgxTZw4sdzvBUzCzA2US2UvBtLZyr8klZSUqEOHDurQoYPCwsI0ZcoU2+JUCxYs0ObNm3XnnXdq5syZ2rJli3JycvTBBx+Uqw/R0dH6/vvv9fXXX9v2bdy4URaLpVwLOklnL0K/Hg1w+vRpffrppxU6V0lauHChUlJS9MEHH9gugJJUu3Zt2/k72oKCgsp1/EGDBmn27NkqKiqSJL322ms6fPiwevXqVaF+vvXWWyorK1Pv3r0r9D4AAExE1ik/T886oaGh2r59u92+t99+W9LZmxIAANREZJ3y8/Ssc05ZWZnS0tJ0++2368Ybb6zQewFTMHMD1a558+b6wx/+oD//+c86evSowsPDlZaWpi+++EJz5syRJB0+fFhPPvmkSkpK1LhxY73++uuSJKvVWq7PGDx4sCZPnqz+/ftr4sSJ+vHHHzVmzBjdd9995T7Gn//8Z/Xs2VMPP/yw4uPj9dJLLyk3N7dC5zp58mS9+uqr2rx5sxo1alSh95bXo48+quXLlys6OlpdunTRypUrlZCQoKioKEnS0aNHlZ2drWuuuUaBgYEXPM6GDRvUqVOni74GAABcGlnHuaqadRITE3XHHXfotttuU8eOHbVv3z69+eabio+PV9OmTaulzwAAmIys41zOuq+zcuVKffHFF3rttdeqpZ+AN2DmBlxi7ty56t+/vx5++GElJCTI19dXGzZs0GWXXSZJ+tvf/qYhQ4bob3/7m3r27Km33npLCxYsUIcOHcp1/MDAQG3cuFGtW7fWnXfeqccee0wPPPCAXnzxxXL3sUePHlqyZInefvtt9evXTydPntTAgQPL/f6vv/5ab7/9drVeAKWzz2fcsWOHrr/+eu3Zs0cPP/yw3aOldu7cqejoaGVnZ1/0OBs3blS3bt2qrZ8AANQkZB3nqWrW+f3vf69ly5Zp//79mjJlijZs2KABAwZo4cKF1dZnAABMR9ZxHmfc1zlz5ozGjx+vBx98UK1ataq2vgKezlJW3gfXAQAAAAAAAAAAeABmbgAAAAAAAAAAAK9CcQMAAAAAAAAAAHgVihsAAAAAAAAAAMCrUNwAAAAAAAAAAABeheIGAAAAAAAAAADwKhQ3AAAAAAAAAACAV6G4AQAAAAAAAAAAvArFDQAAAAAAAAAA4FX83N2BwI4j3N0FQJKU/8lMd3cBkCTVqW1x6vGc8f/siV0vOKEnQM1E1oGnyP+UrAPPUKcWWQcwCVkHnuKnT/m/HJ4hsFY1HJO845DbixsAgGpmYZIeAAAwGFkHAACYjrzjEMUNADCdxbmjIwEAADwKWQcAAJiOvOMQJR8AAAAAAAAAAOBVmLkBAKZj6iIAADAZWQcAAJiOvOMQxQ0AMB1TFwEAgMnIOgAAwHTkHYcobgCA6ajuAwAAk5F1AACA6cg7DvGtAAAAAAAAAAAAr8LMDQAwHVMXAQCAycg6AADAdOQdhyhuAIDpmLoIAABMRtYBAACmI+84RHEDAExHdR8AAJiMrAMAAExH3nGIkg8AAAAAAAAAAPAqFDcAwHQWn6pvFbRgwQI1adJEderU9/S3vgAAV65JREFU0c0336xvvvlGkrRnzx5FR0erQYMGGjt2rMrKymzv2bJli9q0aaPQ0FBNnTrV7nirVq1S06ZNFR4eruXLl9u1zZo1S2FhYWrevLk2btxYiS8IAAB4NTdkHQAAAJci7zhk5lkBAP6fxVL1rQK+/vprPfXUU1q7dq327t2rFi1aaOjQoSopKVF8fLyioqK0Y8cOZWVlafHixZKkvLw8JSQkKCkpSRkZGVq2bJk2bdok6WxBZMiQIZowYYLWr1+v1NRUZWdnS5LWr1+vMWPGaN68eVq6dKmSk5OVn5/v1K8PAAB4OBdnHYmBHAAAwMXckHe8AcUNADCdi6v7u3btUteuXdWpUyddddVV+uMf/6ivvvpK77zzjgoLCzV16lS1aNFCEydO1MKFCyVJy5YtU3h4uCZMmKDIyEilpqba2hYsWKAePXooOTlZ7dq104gRI7RkyRJJ0pw5c3TvvfcqMTFR3bp1U2JiotasWePc7w8AAHg2F2cdBnIAAACXc3He8ZaBHBQ3AMB0Tqjul5SUqKioyG4rKSlx+HFt27bVxo0b9dlnn6mwsFCzZ8/W7373O2VmZqpr166qU6eOJKl9+/bKysqSJGVmZqpHjx6y/G8kQZcuXbRz505bW8+ePW3HL28bAACoIVw8kpGBHAAAwOVcmHe8aSAHxQ0AwCWlpaWpXr16dltaWprD17Zt21aDBg1Sx44dVb9+fWVkZGjKlCkqKiqS1Wq1vc5iscjX11cFBQXntQUHB+vgwYOSVOk2AACA6sBADgAAYDJvGshBcQMATOeEqYspKSkqLCy021JSUhx+3Keffqp169bp3//+t37++WclJSWpT58+8vPzk7+/v91rAwICdPz48fPazu2XVOk2AABQQzgh61R0lioDOQAAgEu58LFU3jSQg+IGAJjOCRdAf39/BQcH222/LVScs3z5cg0ePFjXX3+96tWrp2eeeUZff/21QkJClJeXZ/fao0ePqnbt2ue1ndsvqdJtAACghnBC1qnILFUGcgAAAJdz4WAObxrIQXEDAEznY6n6VgGlpaX68ccfbT8fPXrU9kd9RkaGbX9OTo5KSkoUEhKi6Ohou7Zdu3YpIiJCkirdBgAAaggnZJ2KzFJlIAcAAHA5J+Sd8g7m8KaBHBQ3AABOFRMTozfeeEPTpk3Tq6++qttvv12NGjXSyJEjVVRUpEWLFkmSJk6cqF69esnX11cJCQnatm2bNmzYoNOnT2vy5Mnq3bu3JGngwIFasWKFdu/ereLiYs2YMcPWNmjQIM2ePVu5ubk6fPiwFi5caGsDAAAor4rMUmUgBwAA8EblHczhTQM5KG4AgOlc+FxG6Wwx4rHHHtPzzz+voUOH6ueff9aaNWtUq1YtLViwQCNGjFBoaKjWrl2rSZMmSZJCQ0M1bdo09enTR2FhYcrOztb48eMlSdddd51GjRqlzp07KyIiQr6+vho+fLgkKT4+XnFxcYqMjJTValXHjh01YMAA535/AADAs7k46zCQAwAAuJwLHznuTQM5LGVlZWXlfnU1COw4wp0fD9jkfzLT3V0AJEl1alfsMVCXEhg3scrHOPHB353Qk7MOHTqknTt3qmvXrmrYsKFdW05Ojvbu3auYmBgFBQXZtWVlZSk3N1exsbHnVfG3b9+uY8eOKTY21rZ4FeApyDrwFPmfknXgGerU8u6sU1ZWpmeeeUYLFizQDz/8oGuvvVYLFy5Ux44dlZ6erqSkJAUGBsrHx0ebN29W27ZtJUlz587VyJEjFRQUZHt+dVhYmCRp3LhxmjJligICAhQZGamtW7cqMDBQZWVluueee7R69WpJUlxcnNLT08k78ChkHXiKnz59wd1dACRJgbWq4ZguzDurVq3Svffeq2eeeUZhYWFasGCBvvnmG3355ZeKiIjQpEmTdN999+n+++/XoUOHtG7dOh05ckRNmjTRunXrFBsbq4SEBLVs2VIzZ85UZmambrzxRmVkZMhqtSomJkZ33323Ro8erfT0dA0bNkzbt2+Xn5+foqKiNH36dA0cOLBcfaW4AfwPxQ14CqcXN3o9W+VjnNjwmBN6AtRMZB14Coob8BROL254WNZhIAdqGrIOPAXFDXiKailuuDDveNNADoobwP9Q3ICnoLgBmIWsA09BcQOewvTiBlDTkHXgKShuwFN4e3HjUjxpIIdf5U8DAOAVGN0HAABMRtYBAACm86C806hRI/Xt29dhm9VqldVqddjWtm1b2yyP34qOjq5UXyhuAIDpKrhIJgAAgFch6wAAANORdxyiuAEApvOg6j4AAIDTkXUAAIDpyDsOUfIBAAAAAAAAAABehZkbAGA6pi4CAACTkXUAAIDpyDsOUdwAANMxdREAAJiMrAMAAExH3nGI4gYAmI7qPgAAMBlZBwAAmI684xDfCgAAAAAAAAAA8CrM3AAA0zF1EQAAmIysAwAATEfecYjiBgCYjqmLAADAZGQdAABgOvKOQxQ3AMB0XAABAIDJyDoAAMB05B2H+FYAAAAAAAAAAIBXYeYGAJiO5zICAACTkXUAAIDpyDsOUdwAANMxdREAAJiMrAMAAExH3nGI4gYAmI7qPgAAMBlZBwAAmI684xAlHwAAAAAAAAAA4FWYuQEApmPqIgAAMBlZBwAAmI684xDFDQAwHVMXAQCAycg6AADAdOQdhyhuAIDhLFwAAQCAwcg6AADAdOQdx5jPAgAAAAAAAAAAvAozNwDAcFT3AQCAycg6AADAdOQdxyhuAIDpuP4BAACTkXUAAIDpyDsOUdwAAMNR3QcAACYj6wAAANORdxxjzQ0AAAAAAAAAAOBVmLkBAIajug8AAExG1gEAAKYj7zhGcQMADMcFEAAAmIysAwAATEfecYziBgAYjgsgAAAwGVkHAACYjrzjGGtuAACcavHixbJYLOdtixcv1pYtW9SmTRuFhoZq6tSpdu9btWqVmjZtqvDwcC1fvtyubdasWQoLC1Pz5s21ceNGu7Zx48apQYMGat++vT7//PNqPz8AAAAAAAC4HzM3AMB0Li7u33XXXbr99tttPxcXF6tjx45q06aNbrnlFo0ePVpJSUkaPHiwOnbsqB49emjPnj0aMmSIZs2apeuvv14DBgxQp06d1Lp1a61fv15jxozRihUrdPnll+vuu+/W9u3b1bBhQ7344ot68cUXlZ6eroKCAg0ePFifffaZateu7dqTBgAA7sNARgAAYDryjkPM3AAAwzmaRVHRrSJq166t+vXr27ZXXnlF/fv3V0ZGhsLDwzVhwgRFRkYqNTVVCxculCQtWLBAPXr0UHJystq1a6cRI0ZoyZIlkqQ5c+bo3nvvVWJiorp166bExEStWbPG1jZmzBjFxMQoISFBrVu31ocffujcLxAAAHg0V2cdZqkCAABXc2Xe8aasQ3EDAAzn6j/4f+3kyZOaPn26/v73vyszM1M9evSwHa9Lly7auXOnJCkzM1M9e/a0va88bWVlZdq9e/cF3wcAAGoGV2edu+66SwUFBbbt+++/V2hoqNq0aaOEhAQlJSUpIyNDy5Yt06ZNmyTJNkt1woQJWr9+vVJTU5WdnS1Jtlmq8+bN09KlS5WcnKz8/HxJspul+swzz2jw4ME6deqUc79AAADg8VyZd7wp61DcAABcUklJiYqKiuy2kpKSS77v1Vdf1fXXX69mzZqpqKhIVqvV1hYcHKyDBw9KUqXaiouLVVpaesH3AQAAVAdmqQIAAJN5U9ahuAEAhnNGdT8tLU316tWz29LS0i752XPnztWwYcMkSX5+fvL397e1BQQE6Pjx45Vu8/M7u2zUhd4HAABqBmdkncoO5GCWKgAAcAV3PZXD07MOxQ0AMJwzLoApKSkqLCy021JSUi76uV999ZW++uor/e53v5MkhYSEKC8vz9Z+9OhR28LflWkLDAxUYGDgBd8HAABqBncO5GCWKgAAcAV3Debw9KxDcQMATGep+ubv76/g4GC77dczJhxZuXKl+vXrp1q1akmSoqOjlZGRYWvftWuXIiIiqtTWuXPnC7YBAIAawglZpzIDOSRmqQIAABdxQt6pzGAOT886FDcAANXi3Xff1c0332z7OSEhQdu2bdOGDRt0+vRpTZ48Wb1795YkDRw4UCtWrNDu3btVXFysGTNm2NoGDRqk2bNnKzc3V4cPH9bChQvt2iZNmqSioiLt27dPq1atsrUBAACUV2UGcjBLFQAAeJOKDubwhqxDcQMADOeO5zKeOHFCn3zyibp162bbFxoaqmnTpqlPnz4KCwtTdna2xo8fL0m67rrrNGrUKHXu3FkRERHy9fXV8OHDJUnx8fGKi4tTZGSkrFarOnbsqAEDBkiSHnzwQV1xxRVq3Lix2rVrp6FDhyoqKsoJ3xoAAPAW7noGNbNUAQCAqzgj71R0MIc3ZB2KGwBgOHf8wR8YGKiSkhJdffXVdvuHDRum7OxsLVu2TJ9//rnCwsJsbf/4xz+0a9curVq1Sh9//LECAwNt/V+yZIm2bNmit99+W+np6bY++fv76/3339dbb72lrVu3atasWVX4pgAAgDdyV3GDWaoAAMBV3JF3vCHr+FX4rAAAXqWyf7BXF6vVardY1K+1bdtWbdu2ddgWHR3tcL+Pj49iYmKc1j8AAOBd3JF1zs1SnTdvnm3fr2epBgUFqX79+lq8eLEk+1mqAQEBioyMtJul+vrrrysyMlKSFBcXZzdLde3atWrcuLFKSkqUnJzMLFUAAGogV+cdb8k6lrKysjInnXOlBHYc4c6PB2zyP5np7i4AkqQ6tZ17wbrijyurfIwfX7rDCT0BaiayDjxF/qdkHXiGOrXMzjo5OTnau3evYmJiFBQUZNeWlZWl3NxcxcbGnvc86e3bt+vYsWOKjY21u4FRWlqqbdu2yd/fX126dHFaPwFnIevAU/z06Qvu7gIgSQqs5fxjelLe8aSsw8wNADCdZ03cAAAAcC4PyzrMUgUAAE7nQXnHk7IOxQ0AMJynPZYKAADAmcg6AADAdOQdxyhuAIDhuAACAACTkXUAAIDpyDuO+bi7AwAAAAAAAAAAABXBzA0AMBzVfQAAYDKyDgAAMB15xzGKGwBgOC6AAADAZGQdAABgOvKOYxQ3AMB0XP8AAIDJyDoAAMB05B2HWHMDAAAAAAAAAAB4FWZuAIDhmLoIAABMRtYBAACmI+84RnEDAAzHBRAAAJiMrAMAAExH3nGM4gYAGI4LIAAAMBlZBwAAmI684xhrbgAAAAAAAAAAAK/CzA0AMB3FfQAAYDKyDgAAMB15xyGKG4a6IuQyXXVliLK+/kHHT55yd3cAuBFTFwEAgMnIOgAAwHTkHcd4LJUHGNr/Bn35ztPK/3iq1s8fpWYRDc97zdoXhuvu+Ovt9jVvEqrczZPOe+2Iu25W5psTNO+pu/XV+md0Y8cWtrabolpq1+rx+n7jsxp5d0/nnwyMU1BQoL63xulg7oFy7T9n+tQpGjViWIXb4HwWi6XKGwBURWWyzuvPP6gTu16wbW/NHWH3+gvloEu1AReS/uYb6njt1edt6W++oXlzZyuu+43qFt1Jo0Y8pIKCAtv7Ro14yO71Dybf58azqJnIOgDcraJZZ9yDfexyzrktJipSkjT973cqd/Mk/fDhZM178m4F+NeyHad/rw7KfvspffPeP3THrVGuOUEYYdLEZ9Th2ta2Lf6239naCgp+Up/ePZV7gXs8z0/9p0b+mfs47kTecYzihptZG4fq7/ffpt8//KI6DHha3xzI0/yn/mD3msG3ddYtN7a129csoqHenDlcIfXq2u1v3iRUo++7RVED/6FOA/+hWa9uVurwfpKk0AZBWjXtQa1cv0M3D31Od97WWd07R1bvCcKrFRQUaNSIYTqYm1uu/efsy87Wytde1dhHx1WoDQBgnspmnai2Vylq0D/UKGasGsWM1e//Os/WdqEcdKk24GJu69tPH378qW17d8Nm1W/QQOERjfXeu+9o4ctLtGL1GpX+UqrnJj9re1/WF3v0+pp02/uenzHLjWcBAHC1ymSdKYves2WcRjFj1eXONP3401FlZn+vu/p1UaumV+iGpGfV64/Pq22LKzX2j7dIktq2uFKL/nGv0ua/o/jhszThob6KbHqFS88X3uuLL/Zo5ux5+vDj7frw4+1asWqNpLOFjZF/vtg9nr1aueJV/e0x7uPA81DccLMOVzfWp7v367O9B/T9oQK98ua/1aLJ5bb2BsF1lPbIAGXnHLJ73+rpw/TS6m3nHc+/lp9GPLNcB/MKJUmf7f3e9sf94Ns664e8QqXNe1dff5entPnvaOjtN1Tj2cHbPTb2Ed3ap2+590tSaWmpnnkqVUP+MFSNmzQpdxuqD9V9AO5UmawTfnk9SVLW1z+osPiECotP2D1m80I56FJtwMXUqlVblwUH27Z/pb+pnnG9lLVnt26K6a5m1ua66qqmuq1vP33/3beSpB8PH5bKpJaRrWzvC6xTx81nUvOQdQC4U2WyTsmpM7aMU1h8Qg/e0V0vLNukouKTir6mqdZs+Ezf/VCgL746qPRNn9uOd1//btqy/UstXpOhL746qLkrPtRdfbu4/Jzhfc6cOaNvvv5SUZ07Kzg4WMHBwapbN0jS2Xs8t/Xp5/B9paWlevrJVN19D/dx3I2841ilixuFhYX64YcflJ+fr7KyMmf2qUb57zeHFBvdSu1bRSg4KEAP3BGjD/6919b+7CMDlL4pU5/u3m/3vgEj5+qNDbscHu+tLbslSXUCauvBO7orfVOmJKldq8basmOf7bU79nyrjm2uqoazgilSn3hadw25p9z7JWnVyhX68st9Co+I0OZNG3X69KlytaH6cAEEKoes4xyVyTqdr20qX18fffXu0zry8XN65dn7VP+yQFv7hXLQpdqA8iopKdGrS5foT/c/qOYtI7Xxgw068P33+ik/X2++sUpdb+gmSdqz+3P9UvqLesfF6obojnp0zCMqKix0c+9rHrIOUDlkHeeo7H2dc668vJ4SerbX7OWbJUlZ3/ygpL7R/1tLtYF+3zvKdrx2rSK0Zfuv7ut88a06tuWGMy7tqy/3qbS0VHcOvF3XR7XX8Af/pB9+OCjpf/d47nZ8j+f1lcvP3scJj9DmTR9wH8eNyDuOVai48fLLLysmJkYNGzZUq1atdP3116tly5YKCgpSYmKi9u7de9H3l5SUqKioyG4rK/2lSifg7fZ+c0hrPvhMn7yWosNbp+j69lalTDs7Lax750j16NJK455/87z3fXsw/6LH7X1TW+W8/w9deXk9pc1/R5IUHBSgb3P//31FxSd15f9GRgKORDRuXKH9x48f05zZM9U4orF+OJirZUsW6757hujkyZMXbUM1szhhA2oIso7zVSbrtLI20u59ueo/cq5i73lOzcIb6qmRibb2i+WgS2UkoDzeeetfurZ9e4VHNNZNMd3VpEkTxd/2O8XF3qjjx4/rvuQHJEk5Od+oVaurNWPWi3pl2QodzD2gGc9PdXPvayCyDlBuZB3nq+x9nXOSB92k19/dqWMnzt40XrTmY9UN9Ne3H6Qp++2ntf9gvpau+0SSdFndAO23u69zgvs6KJevv/5KzZpZ9UzaZK18I12+vn56+okJkqSIxo4LZMePH9PcWTPVuHETHTx4UEtfWayhf7iL+zjuQt5xqNzFjUcffVSrVq3SrFmzlJ+fr8OHD+u7775TQUGB9uzZoyuuuEI333yz3eJ6v5WWlqZ69erZbWcO73TKiXirztc0Vd/u16r7H/6psJgxWvnuTr058yEF+NfSC+OTNHLiayo+XlLh427I2KuBf31RkvT0X87eDDhz5heVnD5je83JU6dVJ6C2c04EkPTBhvd18sQJzXvpFT3055GaM+8lHT92TG+tW3vRNlQvqvtA+ZB1qkdlss6Ul95Tv4de0O59ufriq4NKeX6N+sd1cM8JoEZatXKFBt0xWJL0/nvv6ocfftDqtW/pgw8/VouWLTXusbGSpD/d/6DmLnhJra++WpGtWuuvo8fqg/fXu7PrNRJZBygfsk71qMp9HR8fi+7r303zV31k2zciqYcKi0+o1W0TFHnrePn5+ijt4dslSb/8Uvqb+zpnuK+DcunbL0GvrnxD13XoqKZNm+nvEx7XvzM+VnFx8QXf88H77+vEiROa/9LLGj5ipObOX6Tjx47pX9zHcQvyjmPlLm4sWLBAM2bMUPv27c9rs1qtmj9/vn755Rf9+9//vuAxUlJSVFhYaLf5hUVVrueGuOPWKL2+fqe27/lWRcUn9cSsdbI2DtWr//yTdn7xrd796ItKHfeXX0r10c6vNHry67r3f+tq/FR0XKENgmyvuaxOgE6dOXOhQwAV9uPhQ2rX/jo1aNBAkuTn56fIVq31/fffXbQNADwBWad6OCPr5P1UrNAGQapdy88FPUZN99133+r7776zPXrqnX/9S7+/c7Cat2ihkJAQjXn079q44X0dLSo6770hIQ31888/69QpHtkAwPOQdapHVbJObHQr/VR4THu/+f/1OO7s01nTXt6g7w8V6MDhn5U6M/1X93WO/ea+jr9Ona7ZM2dQOSEhDVVaWqojeT9e8DWHbfdxQiT96j7O/9YeAzxBuf9CbNGihaZMmaLnnntOAQEB57W//PLLOnHihKKiLnxR8/f3l7+/v90+i49vBbprHh8fixoG/+rCVDdAdQJq67aYa1V8vEQ/fDhZ0tn1Mwb+rpM6X9tUf01becHjDbqlkyLC6mv6ko2SpNOnf9Evv5RKknZ+8a3uvK2z7bXXXd1YB3/kmcBwnivCGp03PfGHHw7qug4ddVlw8AXbUL1Mrc4DzkbWqR6VyToN69XVnBVb9PFn30iSrm9v1aEjRTp1mkEZqH7vv/uOYmJvVq1atSRJpWWl+umnn2zt+UfyJEm/lP6iR0c/rMFD7lbHTmf/X/g8c5caNgxV7dqMonUlsg5QPmSd6lGV+zoDf9dJazdmnne8y0Mus/0c1jBYvj5nxybv/OI7Xd/eqpffzJAkXXd1Ex388efqPD0YYuqUSbq6TVv16Rsv6Wxm8fHxUVijKy/4nrCwRiopsZ91xH0c9yHvOFbu4sZLL72khIQEvfbaa+ratausVqv8/f2Vl5enjz/+WEePHtXy5ct1xRVXVGd/jbNt19ea/9Qf9NneHvox/6iG9r9Bh/OL1OuP0+Tj8/8Ta559pL8+/Xy/lqy78AgKSdq3/7Bmp96lnANH9NneA/r7g7fZFtV8a8tuPf/YHepxfWtt3fmlHhnaSxsy/lut54eaJaZ7rCanPaPXV65Q9+4364MP3tO+7L2a/NzzCggIuGAbqhfXP6B8yDrVozJZJ3nQTZo8ZqD+NmW1GtYP0lN/SdD817e68SxQk2zb9pESEvvbfu7UKUovL3pJV1wRJv8Af7265BVd16Gj6tdvoJatWmnKpDSNeTRFPxcUaObz0/T7Owe7sfc1E1kHKB+yTvWoyn2dW7q10f2PL7U73sf/+Vpj7vudfvmlVLVr+Wn00F56a8tuSdKbH3ymjYse0axXN2t/7hENT4rVire3u+ZE4dVat75as2Y+r4YNQ/XLL79oUtrT6pdwuwIDAy/4npjYWE1Ke1qvv7Zc3WN76IMNZ+/j/PO56S7sOc4h7zhW7uLGtddeq7179+rtt9/W559/rqKiIvn5+emaa67R0KFD1b17d/n61uxqfWWs2fCZWlsbacSQHmoUGqwvvvpBdz4yXwcO/2z3uuLjJTryc7Hyfz520eN9vi9Xf3lmhSaNHqB6l9XRmg279NjUNyRJ+T8f09+ee0NvznxIxcdLVHj0hB5IXXrR4wEVUb9+A82cPU9Tp0zS1H8+q9DQyzVpyjQ1+t9IgIu1ofpQ3QfKh6xTPSqTdZ5b/L6aRTTU2ll/1tFjJzXv9Q81eeF77jkB1CgnT57Uns8zNeHxp2z7Bg/5gw4dOqT5L87WzwUFan9dBz35TJokaegfk5V74ID+/OD9qlu3rn4/OEl/uv9Bd3W/xiLrAOVD1qkelb2vY20cqisvr6cde/bbve6JWf/SZUEB+sdfb9dldfy1IeO/GvPPVZKk3ftyNevVzdq2bKxOlpzRV9/n6cWVDADBpfWNT9TXX32l0Q//Rb4+vurTL14jRz1y0fecu8cz7bnJeu5/93EmP/e8Gl3JfRx3IO84ZikrKytzZwcCO45w58fXSE3DG6q1NUzb/vOVjp3gecDn5H8y091dACRJdWo794IVOfbdKh/jy3/e6oSeADUTWQeeIv9Tsg48Q51aZB3AJGQd17u6eSOFX15fW3d+qdNnWHPjnJ8+fcHdXQAkSYG1nH9M8o5jrMpYA317MF/fHsx3dzcAuAjFfQAAYDKyDoCaZu83h+wWIQdgPvKOYxQ3AMBwTF0EAAAmI+sAAADTkXcco7gBAIbj+gcAAExG1gEAAKYj7zjm4+4OAADM9eijjyo+Pt728549exQdHa0GDRpo7Nix+vWyT1u2bFGbNm0UGhqqqVOn2h1n1apVatq0qcLDw7V8+XK7tlmzZiksLEzNmzfXxo0bq/eEAAAAAAAA4BEobgCA4Xx8LFXeKuPzzz/X7NmzNX36dElSSUmJ4uPjFRUVpR07digrK0uLFy+WJOXl5SkhIUFJSUnKyMjQsmXLtGnTJklnCyJDhgzRhAkTtH79eqWmpio7O1uStH79eo0ZM0bz5s3T0qVLlZycrPx81hQCAKAmcVfWkRjIAQAAXMOdeceTUdwAAMNZLFXfKqq0tFQPPPCAHn74YTVv3lyS9M4776iwsFBTp05VixYtNHHiRC1cuFCStGzZMoWHh2vChAmKjIxUamqqrW3BggXq0aOHkpOT1a5dO40YMUJLliyRJM2ZM0f33nuvEhMT1a1bNyUmJmrNmjXO+eIAAIBXcEfWkRjIAQAAXMddecfTB3JQ3AAAw1kslipvJSUlKioqsttKSkou+Jlz587V7t271axZM6Wnp+vUqVPKzMxU165dVadOHUlS+/btlZWVJUnKzMxUjx49bAtkdenSRTt37rS19ezZ03bs8rYBAICawRlZp6IYyAEAAFzJHXnHGwZyUNwAAFxSWlqa6tWrZ7elpaU5fG1xcbEef/xxNW/eXN9++62mTZumm266SUVFRbJarbbXWSwW+fr6qqCg4Ly24OBgHTx4UJIq3QYAAFBeDOQAAAD4f94ykIPiBgAYzhlTF1NSUlRYWGi3paSkOPy8N954Q8eOHdOmTZv05JNP6v3339fRo0f10ksvyd/f3+61AQEBOn78uPz8/Ozazu2XVOk2AABQMzgj6zCQAwAAeDJn5J2KDObwloEcFDcAwHDOmLro7++v4OBgu+23hYpzDhw4oK5duyo0NFTS2QJE+/bt9fPPPysvL8/utUePHlXt2rUVEhJi13Zuv6RKtwEAgJrBGVmHgRwAAMCTOSPvlHcwhzcN5KC4AQCGc/VzGRs3bqwTJ07Y7fv222/1/PPPKyMjw7YvJydHJSUlCgkJUXR0tF3brl27FBERIUmVbgMAADUDAzkAAIDpXDmYw5sGclDcAAA4Vd++fZWVlaW5c+fqwIEDmjFjhjIzMzVgwAAVFRVp0aJFkqSJEyeqV69e8vX1VUJCgrZt26YNGzbo9OnTmjx5snr37i1JGjhwoFasWKHdu3eruLhYM2bMsLUNGjRIs2fPVm5urg4fPqyFCxfa2gAAAKoDAzkAAIA3Ku9gDm8ayEFxAwAM54znMlZEw4YN9fbbb+vll19Wq1atNH36dK1cuVJNmjTRggULNGLECIWGhmrt2rWaNGmSJCk0NFTTpk1Tnz59FBYWpuzsbI0fP16SdN1112nUqFHq3LmzIiIi5Ovrq+HDh0uS4uPjFRcXp8jISFmtVnXs2FEDBgxw6vcHAAA8m6uzDgM5AACAq7ky73jTQA5LWVlZWflPzfkCO45w58cDNvmfzHR3FwBJUp3aFfwL+xI6PrmxysfY9XjPS7+onA4dOqSdO3eqa9euatiwoV1bTk6O9u7dq5iYGAUFBdm1ZWVlKTc3V7GxsedV8bdv365jx44pNja2wo/RAqobWQeeIv9Tsg48Q51a3p91tm3bpjFjxigzM1NXXnmlnn/+ecXHxys9PV1JSUkKDAyUj4+PNm/erLZt20o6uzDnyJEjFRQUpPr16ysjI0NhYWGSpHHjxmnKlCkKCAhQZGSktm7dqsDAQJWVlemee+7R6tWrJUlxcXFKT08n78CjkHXgKX769AV3dwGQJAXWcv4xXZl38vPz1bx5c02aNEn9+vXTG2+8oUcffVT79u1TVFSUJk2apPvuu0/333+/Dh06pHXr1unIkSNq0qSJ1q1bp9jYWCUkJKhly5aaOXOmMjMzdeONNyojI0NWq1UxMTG6++67NXr0aKWnp2vYsGHavn27/Pz8FBUVpenTp2vgwIHl6ivFDeB/KG7AUzi7uNHpqapfAP+T6rziBlDTkHXgKShuwFM4u7jhaVmHgRyoacg68BQUN+ApqqO44eq84y0DOShuAP9DcQOeguIGYBayDjwFxQ14CtOLG0BNQ9aBp6C4AU9hQnHjYjxpIIdf5U8DAOANGN0HAABMRtYBAACm86S806hRI/Xt29dhm9VqldVqddjWtm1b2yyP34qOjq5UXyhuAIDhPOj6BwAA4HRkHQAAYDryjmMUNwDAcJ5U3QcAAHA2sg4AADAdeccxH3d3AAAAAAAAAAAAoCKYuQEAhqO4DwAATEbWAQAApiPvOEZxAwAMx9RFAABgMrIOAAAwHXnHMYobAGA4rn8AAMBkZB0AAGA68o5jrLkBAAAAAAAAAAC8CjM3AMBwTF0EAAAmI+sAAADTkXcco7gBAIbj+gcAAExG1gEAAKYj7zhGcQMADEd1HwAAmIysAwAATEfecYw1NwAAAAAAAAAAgFdh5gYAGI7iPgAAMBlZBwAAmI684xjFDQAwHFMXAQCAycg6AADAdOQdxyhuAIDhuAACAACTkXUAAIDpyDuOseYGAAAAAAAAAADwKszcAADDUdwHAAAmI+sAAADTkXcco7gBAIZj6iIAADAZWQcAAJiOvOMYxQ0AMBzXPwAAYDKyDgAAMB15xzHW3AAAAAAAAAAAAF6FmRsAYDimLgIAAJORdQAAgOnIO45R3AAAw3H9AwAAJiPrAAAA05F3HKO4AQCG8+EKCAAADEbWAQAApiPvOMaaGwAAAAAAAAAAwKswcwMADEdxHwAAmIysAwAATEfecYziBgAYjkWnAACAycg6AADAdOQdxyhuAIDhfLj+AQAAg5F1AACA6cg7jrHmBgDAqUaOHCmLxWLbWrZsKUnas2ePoqOj1aBBA40dO1ZlZWW292zZskVt2rRRaGiopk6dane8VatWqWnTpgoPD9fy5cvt2mbNmqWwsDA1b95cGzdurP6TAwAAAAAAgEeguAEAhvt1oaGyW0Xs2LFDb731lgoKClRQUKBdu3appKRE8fHxioqK0o4dO5SVlaXFixdLkvLy8pSQkKCkpCRlZGRo2bJl2rRpk6SzBZEhQ4ZowoQJWr9+vVJTU5WdnS1JWr9+vcaMGaN58+Zp6dKlSk5OVn5+vlO/OwAA4PlcnXUYyAEAAFzN1XnHW1DcAADDWSxV38rrzJkz+uKLL9S9e3fVr19f9evX12WXXaZ33nlHhYWFmjp1qlq0aKGJEydq4cKFkqRly5YpPDxcEyZMUGRkpFJTU21tCxYsUI8ePZScnKx27dppxIgRWrJkiSRpzpw5uvfee5WYmKhu3bopMTFRa9ascfr3BwAAPJsrs47EQA4AAOB6rsw73jSQg+IGABjO4oR/JSUlKioqsttKSkrO+6zdu3ertLRUHTp0UGBgoG699VZ99913yszMVNeuXVWnTh1JUvv27ZWVlSVJyszMVI8ePWyjCLp06aKdO3fa2nr27Gk7fnnbAABAzeGMrFNeDOQAAADu4Mq8400DOShuAAAuKS0tTfXq1bPb0tLSzntdVlaWWrdurSVLlujzzz+Xn5+fHnjgARUVFclqtdpeZ7FY5Ovrq4KCgvPagoODdfDgQUmqdBsAAEBFMJADAADA+wZyUNwAAMP5WKq+paSkqLCw0G5LSUk577OGDBmiHTt26IYbblBkZKRmz56t999/X6WlpfL397d7bUBAgI4fPy4/Pz+7tnP7JVW6DQAA1BzOyDoM5AAAAJ7MGXmnPIM5vG0gB8UNADCcMxad8vf3V3BwsN3222KFI1dccYVKS0vVqFEj5eXl2bUdPXpUtWvXVkhIiF3buf2SKt0GAABqDmdkHQZyAAAAT+aMvFOewRzeNpCD4gYAGM6Vi06NHTtWr776qu3njIwM+fj4qF27dsrIyLDtz8nJUUlJiUJCQhQdHW3XtmvXLkVEREhSpdsAAEDN4Yysw0AOAADgyZyRd8ozmMPbBnJQ3AAAOM11112n8ePH64MPPtB7772nYcOG6Z577tEtt9yioqIiLVq0SJI0ceJE9erVS76+vkpISNC2bdu0YcMGnT59WpMnT1bv3r0lSQMHDtSKFSu0e/duFRcXa8aMGba2QYMGafbs2crNzdXhw4e1cOFCWxsAAEB1YCAHAADwVpUZzOHpAzkobgCA4Xwslipv5XX33Xfrzjvv1MCBA5WUlKRbb71VL7zwgvz8/LRgwQKNGDFCoaGhWrt2rSZNmiRJCg0N1bRp09SnTx+FhYUpOztb48ePl3S2WDJq1Ch17txZERER8vX11fDhwyVJ8fHxiouLU2RkpKxWqzp27KgBAwY4/wsEAAAezZVZh4EcAADAHVyVd7xtIIelrKysrELvcLLAjiPc+fGATf4nM93dBUCSVKd2BZ4DVQ4DX6rYYkyOrP5jlBN6Ih06dEg7d+5U165d1bBhQ7u2nJwc7d27VzExMQoKCrJry8rKUm5urmJjY8+r4m/fvl3Hjh1TbGysbfEqwJOQdeAp8j8l68Az1Knl3VknJSVFc+bMka+vr+6++25NnDhRdevWVXp6upKSkhQYGCgfHx9t3rxZbdu2lSTNnTtXI0eOVFBQkOrXr6+MjAyFhYVJksaNG6cpU6YoICBAkZGR2rp1qwIDA1VWVqZ77rlHq1evliTFxcUpPT2dvAOPQ9aBp/jp0xfc3QVAkhRYy/nHdFXeWbp0qVJTUzV//nz98ssv+stf/qJu3bpp/vz5Cg8P16RJk3Tffffp/vvv16FDh7Ru3TodOXJETZo00bp16xQbG6uEhAS1bNlSM2fOVGZmpm688UZlZGTIarUqJiZGd999t0aPHq309HQNGzZM27dvl5+fn6KiojR9+nQNHDiw3OdEcQP4H4ob8BTOLm4MWvSfKh9j1X2dnNAToGYi68BTUNyAp3B2ccOTsg4DOVATkXXgKShuwFNUR3HDlXnHmwZyUNwA/ofiBjwFxQ3ALGQdeAqKG/AUJhc3gJqIrANPQXEDnsLbixsX42kDOfwqdxoAAG/BAD8AAGAysg4AADCdp+SdRo0aqW/fvg7brFarrFarw7a2bdvaZnn8VnR0dKX7Q3EDAAxXkUUyAQAAvA1ZBwAAmI684xjFDQAwHJc/AABgMrIOAAAwHXnHMR93dwAAAAAAAAAAAKAimLkBAIar6GJMAAAA3oSsAwAATEfecYziBgAYzofrHwAAMBhZBwAAmI684xjFDQAwHNV9AABgMrIOAAAwHXnHMdbcAAAAAAAAAAAAXoWZGwBgOIr7AADAZGQdAABgOvKOYxQ3AMBwTF0EAAAmI+sAAADTkXcco7gBAIZj0SkAAGAysg4AADAdeccxihsAYDiq+wAAwGRkHQAAYDryjmMsKA4AAAAAAAAAALwKMzcAwHDU9gEAgMnIOgAAwHTkHccobgCA4XyYuggAAAxG1gEAAKYj7zhGcQMADMf1DwAAmIysAwAATEfecYw1NwAAAAAAAAAAgFdh5gYAGM5CeR8AABiMrAMAAExH3nGM4gYAGI7rHwAAMBlZBwAAmI684xjFDQAwHItOAQAAk5F1AACA6cg7jrHmBgAAAAAAAAAA8CrM3AAAw1HcBwAAJiPrAAAA05F3HKO4AQCGY9EpAABgMrIOAAAwHXnHMbcXNwq2v+DuLgCA0Xj+IOBeZB0AqF5kHcC9yDoAUP3IO47xvQAAAAAAAAAAAK/i9pkbAIDqxdRFAABgMrIOAAAwHXnHMYobAGA4H65/AADAYGQdAABgOvKOYzyWCgAM52Op+lZZt956qxYvXixJ2rJli9q0aaPQ0FBNnTrV7nWrVq1S06ZNFR4eruXLl9u1zZo1S2FhYWrevLk2btxo1zZu3Dg1aNBA7du31+eff175jgIAAK/lzqwDAADgCuQdxyhuAACqxbJly7R+/XpJUl5enhISEpSUlKSMjAwtW7ZMmzZtkiTt2bNHQ4YM0YQJE7R+/XqlpqYqOztbkrR+/XqNGTNG8+bN09KlS5WcnKz8/HxJ0osvvqgXX3xR6enpeuaZZzR48GCdOnXKPScLAABqJAZyAAAAuA/FDQAwnMViqfJWUT/99JNGjx6t1q1bSzpb6AgPD9eECRMUGRmp1NRULVy4UJK0YMEC9ejRQ8nJyWrXrp1GjBihJUuWSJLmzJmje++9V4mJierWrZsSExO1Zs0aW9uYMWMUExOjhIQEtW7dWh9++KGTvjUAAOAt3JF1JAZyAAAA13FX3vH0gRwUNwDAcO6Yujh69Gj1799fXbt2lSRlZmaqR48etotply5dtHPnTltbz549be8tT1tZWZl27959wfcBAICawx1Zh4EcAADAldyRd7xhIAfFDQAwnMVS9a2kpERFRUV2W0lJicPP27Rpkz744ANNnjzZtq+oqEhWq9X2c3BwsA4ePFjptuLiYpWWll7wfQAAoOZwRtapKAZyAAAAV3J13vGWgRwUNwAAl5SWlqZ69erZbWlpaee97uTJk3rwwQc1Z84cXXbZZbb9fn5+8vf3t/0cEBCg48ePV7rNz89Pki74PgAAgIpgIAcAADBdRfKOtwzkoLgBAIbzsViqvKWkpKiwsNBuS0lJOe+znn76aUVHR6tv3752+0NCQpSXl2f7+ejRo6pdu3al2wIDAxUYGHjB9wEAgJrDGVmHgRwAAMCTuTLveNNADr8KvRoA4HWcUcX29/e3++P6Ql599VXl5eWpfv36kqTjx49r5cqVkqRu3brZXrdr1y5FRERIkqKjo5WRkaE//elPF2yLi4s7r61z587KyMhQixYtbG3npksCAICawxlZJyUlRY888ojdPkfZxx0DOYKDg897HwAAqFlclXe8bSAHxQ0AMFxlniNdWVu3btWZM2dsP48ZM0Zdu3bV0KFD1aRJE23YsEGxsbGaPHmyevfuLUkaOHCgbrzxRo0aNUpWq1UzZszQ3XffLUkaNGiQhg0bpvvuu09+fn5auHChpk+fbmubNGmSEhISdOjQIa1atYpFNgEAqIGckXUYyAEAADyZq/KOtw3koLgBAHCaxo0b2/0cFBSk0NBQhYaGatq0aerTp4+CgoJUv359LV68WJJ03XXXadSoUercubMCAgIUGRmp4cOHS5Li4+P1+uuvKzIyUpIUFxenAQMGSJIefPBBrV27Vo0bN1ZJSYmSk5MVFRXlupMFAAA1DgM5AACAybxtIIelrKysrJLn6hQnz1z6NQBQkwQ4uew84d0vq3yMp2+NdEJPpJycHO3du1cxMTEKCgqya8vKylJubq5iY2PPq9Rv375dx44dU2xsrG3xKkkqLS3Vtm3b5O/vry5dujilj4CzkXUAwJ5JWWfo0KG6+eabNXToUM2dO1cjR460DeTIyMhQWFiYJGncuHGaMmWKbSDH1q1bFRgYqLKyMt1zzz1avXq1pLMDOdLT02WxWFRSUqI+ffpo+/bttoEcs2bNqvK5As5G1gEAe87OOpLr8s6BAwcuOpBj3bp1io2NVUJCglq2bKmZM2cqMzNTN954ozIyMmS1WhUTE6O7775bo0ePVnp6uoYNG6bt27fLz89PUVFRmj59ugYOHKgZM2Zo/vz52rZtmw4dOqSOHTvqww8/rNDAVYobAOBhnH0RTF1f9QvgU72dU9wAaiKyDgDYMznrMJADNRFZBwDsVUdxw115x9MHclDcAAAP4+yL4BPvVf0C+MQtFDeAyiLrAIA9sg5gFrIOANirjuKGp+QdTxvIwZobAAAAAAAAAADgoqxWq6xWq8O2tm3bqm3btg7boqOjHe738fFRTExMpftDcQMADOfzq4o4AACAacg6AADAdOQdxyhuAIDhuP4BAACTkXUAAIDpyDuOUdwAAMP5cAEEAAAGI+sAAADTkXcc83F3BwAAAAAAAAAAACqCmRsAYDiLKO8DAABzkXUAAIDpyDuOUdwAAMMxdREAAJiMrAMAAExH3nGM4gYAGI4LIAAAMBlZBwAAmI684xhrbgAAAAAAAAAAAK/CzA0AMJzFQnkfAACYi6wDAABMR95xjOIGABiOqYsAAMBkZB0AAGA68o5jFDcAwHAU9wEAgMnIOgAAwHTkHcdYcwMAAAAAAAAAAHgVZm4AgOF8KO8DAACDkXUAAIDpyDuOUdwAAMPxXEYAAGAysg4AADAdeccxihsAYDiK+wAAwGRkHQAAYDryjmOsuQEAAAAAAAAAALwKMzcAwHA+orwPAADMRdYBAACmI+84RnEDAAzH1EUAAGAysg4AADAdeccxihsAYDgWnQIAACYj6wAAANORdxxjzQ0AAAAAAAAAAOBVmLkBAIbzYe4iAAAwGFkHAACYjrzjGMUNADAc1z8AAGAysg4AADAdeccxihsAYDiq+wAAwGRkHQAAYDryjmOsuQEAAAAAAAAAALwKMzcAwHAU9wEAgMnIOgAAwHTkHccobgCA4ZiiBwAATEbWAQAApiPvOEZxAwAMZ3FTef/nn39Wdna2WrVqpQYNGrilDwAAwHxkHQAAYDp35R1PR9EHAOB0r7/+upo1a6bk5GQ1btxYr7/+uiRpz549io6OVoMGDTR27FiVlZXZ3rNlyxa1adNGoaGhmjp1qt3xVq1apaZNmyo8PFzLly+3a5s1a5bCwsLUvHlzbdy4sfpPDgAA1HhkHQAAYLqff/5Zn3zyiQoKCtzdlQuiuAEAhrM4YauIwsJCDR8+XB9++KF2796tWbNmaezYsSopKVF8fLyioqK0Y8cOZWVlafHixZKkvLw8JSQkKCkpSRkZGVq2bJk2bdok6exNgiFDhmjChAlav369UlNTlZ2dLUlav369xowZo3nz5mnp0qVKTk5Wfn5+Fb4tAADgbcg6AADAdK7OO94ykIPiBgAYzsdiqfJWEUVFRXr++efVvn17SVKnTp2Un5+vd955R4WFhZo6dapatGihiRMnauHChZKkZcuWKTw8XBMmTFBkZKRSU1NtbQsWLFCPHj2UnJysdu3aacSIEVqyZIkkac6cObr33nuVmJiobt26KTExUWvWrHHitwcAADwdWQcAAJjOlXnHmwZyUNwAAMM5o7pfUlKioqIiu62kpMTh5zVp0kRDhgyRJJ0+fVrTpk1T//79lZmZqa5du6pOnTqSpPbt2ysrK0uSlJmZqR49etieIdmlSxft3LnT1tazZ0/b8cvbBgAAagZXj2Qk6wAAAFdzZd7xpoEcFDcAAJeUlpamevXq2W1paWkXfU9mZqYaNWqkd999VzNmzFBRUZGsVqut3WKxyNfXVwUFBee1BQcH6+DBg5JU6TYAAIDyqshAjnPIOgAAwJuUN+9400AOihsAYDiLpepbSkqKCgsL7baUlJSLfm779u313nvvKTIyUsnJyfLz85O/v7/dawICAnT8+PHz2s7tl1TpNgAAUDM4I+tUZiAHWQcAALiKO/KONwzkoLgBAIazWCxV3vz9/RUcHGy3/faPd0efGxUVpZdffllvvPGGQkJClJeXZ/eao0ePqnbt2ue1ndsvqdJtAACgZnBG1qnMQA6yDgAAcBV35B1vGMhBcQMADOfjhK0itmzZorFjx9p+rl27tiwWi9q0aaOMjAzb/pycHJWUlCgkJETR0dF2bbt27VJERIQkVboNAADUDM7IOhUZyEHWAQAArubqvCN5x0AOihsAAKdq1aqV5s2bp3nz5un777/X3//+d91yyy3q06ePioqKtGjRIknSxIkT1atXL/n6+iohIUHbtm3Thg0bdPr0aU2ePFm9e/eWJA0cOFArVqzQ7t27VVxcrBkzZtjaBg0apNmzZys3N1eHDx/WwoULbW0AAADVgawDAABM5k0DOShuAIDhnDF1sSKuvPJKrVq1StOnT9c111yj48eP65VXXpGfn58WLFigESNGKDQ0VGvXrtWkSZMkSaGhoZo2bZr69OmjsLAwZWdna/z48ZKk6667TqNGjVLnzp0VEREhX19fDR8+XJIUHx+vuLg4RUZGymq1qmPHjhowYIBzv0AAAODRyDoAAMB0rsw73jSQw1JWVlZWge/R6U6eceenA4DnCfBz7vFe/6z8CzFdyO87hDuhJ2cdOnRIO3fuVNeuXdWwYUO7tpycHO3du1cxMTEKCgqya8vKylJubq5iY2PPm6K4fft2HTt2TLGxsRW+QQFUN7IOANgj65B1YBayDgDYc3bWkVyfd95//3399a9/1ffff6/evXtr9uzZuvzyy5Wenq6kpCQFBgbKx8dHmzdvVtu2bSVJc+fO1ciRIxUUFKT69esrIyNDYWFhkqRx48ZpypQpCggIUGRkpLZu3arAwECVlZXpnnvu0erVqyVJcXFxSk9PL3feobgBAB7G2RfBVZk/VPkYg6670gk9AWomsg4A2CPrAGYh6wCAveoobnhS3vGkgRzV8FUDADwJzx8EAAAmI+sAAADTeVLeadSokfr27euwzWq1ymq1Omxr27atbZbHb0VHR1eqL570vQAAAAAAAAAAAFwSMzcAwHA8lxkAAJiMrAMAAExH3nGM4gYAGI7LHwAAMBlZBwAAmI684xjFDQAwHMV9AABgMrIOAAAwHXnHMdbcAAAAAAAAAAAAXoWZGwBgOB8mLwIAAIORdQAAgOnIO45R3AAAwzF1EQAAmIysAwAATEfecYziBgAYzkJ1HwAAGIysAwAATEfecYw1NwAAAAAAAAAAgFdh5gYAGI6piwAAwGRkHQAAYDryjmMUNwDAcCw6BQAATEbWAQAApiPvOEZxAwAMR3UfAACYjKwDAABMR95xjDU3AAAAAAAAAACAV2HmBgAYjuo+AAAwGVkHAACYjrzjGMUNADCchecyAgAAg5F1AACA6cg7jlHcAADD+XD9AwAABiPrAAAA05F3HGPNDQAAAAAAAAAA4FWYuQEAhmPqIgAAMBlZBwAAmI684xjFDQAwHItOAQAAk5F1AACA6cg7jlHcAADDUd0HAAAmI+sAAADTkXccY80NAFVWVFSkzz/PVFFhobu7AgAAAAAAAKAGoLjhZQoKftJtt/RUbu4B275nJz6j665pbdv63fo7N/YQJnP0+/fe+nfU55aeejJ1vH4XF6v31r9ja9u0cYP69I5Tp/ZtdceARH3z9dfu6HaN52Op+gYArvTb683aNW/YZZ1z29o1b7i5p6gpGMjh2cg6AACUj6P7Ohe6d0MG9yzkHccobniRgoKf9Jfhw3QwN9duf9YXe/TCnHnamrFdWzO267XVa9zUQ5jM0e/f0aNHNfHpJ/XSy0u1+s11+vu4VE2b8k9J0vfffafUcX/XqIdH6/2NH6pps2Z6MnWcu7pfo1mc8A8AXMXR9aZP3362nLM1Y7ve+2CLGjRooE5Rnd3YU5ioogM5vvxyn+66Y6BuuiFaU6dMUllZmTu6XeORdQB4kwvdSOaagurmKGdf7N4NGdyzkHcco7jhRR4d84hu69vPbt+ZM2f09VdfKiqqs4KDgxUcHKy6dYPc1EOYzNHv37HiYo197O9q1fpqSVKbtm31888FkqRvvvlaox4erd639lHD0FD9/s4k7d37X5f3G2cXnarqBgCu4uh6U6t2bVvOCQ4O1rr0N9Uz7ndqctVVbuolTFTRgRynTp3SyD8PU5trrtHy11brm6+/1to3GcnoDmQdAN7iQjeSuabAFRzl7IvduyGDexbyjmMUN7xI6pNPa8jd99jt+/LLfSotLdUdA29Xl07t9dADf9IPBw+6qYcwmaPfv0ZXXqm+/RIkSadPn9aSV15Wz15nH4sWe3MPDbrjTttr9+/P0VVXNXVdhwEAXsnR9ebXSkpKtGzpK/rTAw+6sFeoCSo6kOOjrR+q+GixxvwtRU2uukp/GfWI1qxe5fJ+AwC8x4VuJHNNgSs4ytnlvXdDBoenorjhRRo3bnLevm++/krNrFb949nJen1Nunz9/PTUExPc0DuYztHv3znZe/cqLvYmffzRVj2aMv689tOnTmnJ4kX6/Z2Dq7OLuACLEzYAcJWLXW8k6e231qldu/aKiGjsoh6hpqjoQI592XvV/rrrFBgYKElq1bo164u5CVkHgLe40I1krilwhUvl7IvduyGDux95xzE/V35YSUmJSkpK7PaV+frL39/fld0wSt9+CbY/uCRp3PjH1ad3nIqLixUUxOOp4BqtWrfW3PkL9c9JaXoydbyee36GXfvsWTMVGBio/gN/76Ye1mw+ps49BDwQWaf6vf7aCj3057+4uxsw0KUGctz/x3tVq1YtrVn3tiSpuLjY7g98i8UiX18fFRUWKrhevWrvL/4fWQdwHbKO85y7kfyHe4fqu+++45oCt7vYvRsyuPuRdxxz6cyNtLQ01atXz27756Q0V3bBeCENG6q0tFRH8n50d1dQg1gsFrW95lo9PfFZfbDhPRUVFdnaPvl3hl5bvkxpk59TrVq13NjLmssd1f21a9eqefPm8vPzU4cOHfTf/559ZueePXsUHR2tBg0aaOzYsXaL5G3ZskVt2rRRaGiopk6dane8VatWqWnTpgoPD9fy5cvt2mbNmqWwsDA1b95cGzdurERvAech61Sv7779Vt9/95263tDN3V1BDXNuIMdVTZvqydSzs1R9fX1Vq3Ztu9fV9vfXiZMn3dHFGo2RjIDrkHWc59c3krmmwN0udu+GDO4ZyDuOlbu48d1335Vru5iUlBQVFhbabWMfTanySdRkU6dM0tv/Wmf7OfOzXfLx8VFYoyvd2CvUFDu2f6qpUybZfq5Vq7YsFot8fM7+13LgwPd67G+jlTI+VS1atnRXN+FiX3/9te677z49++yzys3NVatWrZScnKySkhLFx8crKipKO3bsUFZWlhYvXixJysvLU0JCgpKSkpSRkaFly5Zp06ZNks4WRIYMGaIJEyZo/fr1Sk1NVXZ2tiRp/fr1GjNmjObNm6elS5cqOTlZ+fn57jp1eDmyjud7b/076n7zzRTL4XKOBnLUq1dPBQU/2b3u+LFj/H7WEAzkgDci63iO395I5poCd7rUvRsyeM3kLVmn3MWNm2++WVarVVarVc2aNXO4Wa3Wix7D399fwcHBdhtTF6umVeur9cLM5/XJvzP08baP9MxTj6tfwu225zQC1alps2Za/fpKrVr5mg798INmPj9VN3S7UUFBQTp58qT+MnyYevSIU1zc73T82DEdP3bM7j89uIiLy/v//e9/9eyzz+qOO+5QWFiYHnroIe3atUvvvPOOCgsLNXXqVLVo0UITJ07UwoULJUnLli1TeHi4JkyYoMjISKWmptraFixYoB49eig5OVnt2rXTiBEjtGTJEknSnDlzdO+99yoxMVHdunVTYmKi1qxZU6WvCzUXWcfzbftoqzpHd3F3N1CDXGwgxzXXttPnn31maztw4HudOnVK9Xh8iOu5OOswkAPeiqzjGRzdSOaaAncpz70bMriHcGHe8aasU+7ixqeffqouXbpo+vTpKi0tdbj98ssv5f+W4BT94hPV+9Y+Gv3Xv+ixsaN1400xShnHguJwjcsvv0JTps3QsqWvaEBiX508eULPpE2WJGV8/JG++forrV61Ujd06WTbDh7MdXOvax6LE/5VRL9+/fTAAw/Yfs7OzlZkZKQyMzPVtWtX1alTR5LUvn17ZWVlSZIyMzPVo0cPWf73DMkuXbpo586dtraePXvajlfeNqCiyDqe7eTJk9r9eaY6dOjo7q6gBrnYQI6oztEqPlasN9esliQtnPeiru/aTb6+vm7udc3j6qzDQA54K7KO+13oRnKnqM5cU+AWl7p3Qwb3HK7MO96Udcq9oHhoaKjWrVunpKQkxcfHq2nTpuX+EDhX5hfZdj+Peni0Rj082k29QU3z29+/G7rdqDXpb533uh49e533WriHM9accrRwoL//pRcOPHXqlJ577jk98sgj+uqrr+xGgp1dJM9XBQUFKioqUtu2bW1twcHBOnjwoCSpqKjI7n3lbQMqiqzjWX57DQkICNCOz/a4qTeoqc4N5Jj87ERNnTJJ3W68yTaQw8/PT088+Ywe/dtoTZsyWRYfHy1ctMTNPa6ZXJ11+vXrZ/dzZQdyPPbYY7a22267zXa8Ll266KmnnrK13XXXXXZtH374oZKTk6t6yqiByDrud+5G8rmbyee8/d4HXFPgMr/O2Ze6d0MG9xyuzDvelHUqtKB4aGio3n//fS6AAFDDOFo4MC3t0gsHPv7446pbt66Sk5Pl5+d33gUzICBAx48fP6/t3H5JlW4DKoOsAyDzi2xFRDS2/XxuIMfHn/5HU6bNUEhIiK3t5p5xeuud9/X0xEl6c93brDHmxSqbdc4N5Bg2bNh5gy5+O5CjMoM1GMgBZyPruNe5G8m/3SIiGnNNAVDtKpN3PD3rVKi4AQDwPs54LKOjhQNTUi6+cODGjRs1a9Ysvfrqq6pVq5ZCQkKUl5dn95qjR4+qdu3a57Wd2y+p0m0AALhC6OWXq3vszapfv4G7u1JjuSvrSAzkAOBcXFMAXIi78o6nZx2KGwBgOidcASu6cGBOTo6SkpI0a9Ys2+OmoqOjlZGRYfeakpIShYSEnNe2a9cuRUREOHxfedsAAEAN4YasIzGQAwAAuJAb8o43ZB2KGwBgOFcvsnnixAn169dPiYmJ6t+/v4qLi1VcXKyYmBgVFRVp0aJFkqSJEyeqV69e8vX1VUJCgrZt26YNGzbo9OnTmjx5snr37i1JGjhwoFasWKHdu3eruLhYM2bMsLUNGjRIs2fPVm5urg4fPqyFCxfa2gAAQM3g6qwjMZADAAC4lqvzjrdkHYobAACneu+995SVlaX58+frsssus225ublasGCBRowYodDQUK1du1aTJk2SdPbZv9OmTVOfPn0UFham7OxsjR8/XpJ03XXXadSoUercubMiIiLk6+ur4cOHS5Li4+MVFxenyMhIWa1WdezYUQMGDHDbuQMAAPMxkAMAAJjMm7KOpaysrMz5X0H5nTzjzk8HAM8T4Ofc4+3cX1TlY0Q1C3ZCT846dOiQdu7cqa5du6phw4Z2bTk5Odq7d69iYmIUFBRk15aVlaXc3FzFxsaeN0Vx+/btOnbsmGJjY2WxVHz0JVCdyDoAYM/bs87atWt1++23n7c/JydHn3/+uZKSkhQYGCgfHx9t3rzZNtpx7ty5GjlypIKCglS/fn1lZGQoLCxMkjRu3DhNmTJFAQEBioyM1NatWxUYGKiysjLdc889Wr16tSQpLi5O6enp5B14FLIOANhzdtaRXJt3vCnrUNwAAA/j7Ivgf5xwAezkxOIGUNOQdQDAnulZh4EcqGnIOgBgrzqKG56Udzwp61DcAAAP4/Q/+L91wgWwKcUNoLLIOgBgj6wDmIWsAwD2qqW4Qd5xiDU3AAAAAAAAAACAV6mGOhIAwJNYxKMLAACAucg6AADAdOQdxyhuAIDheCwzAAAwGVkHAACYjrzjGMUNADAc1z8AAGAysg4AADAdeccx1twAAAAAAAAAAABehZkbAGA6yvsAAMBkZB0AAGA68o5DFDcAwHAsOgUAAExG1gEAAKYj7zhGcQMADMeiUwAAwGRkHQAAYDryjmOsuQEAAAAAAAAAALwKMzcAwHAU9wEAgMnIOgAAwHTkHccobgCA6bgCAgAAk5F1AACA6cg7DlHcAADDsegUAAAwGVkHAACYjrzjGGtuAAAAAAAAAAAAr8LMDQAwnIXiPgAAMBhZBwAAmI684xjFDQAwHNc/AABgMrIOAAAwHXnHMYobAGA6roAAAMBkZB0AAGA68o5DrLkBAAAAAAAAAAC8CjM3AMBwFsr7AADAYGQdAABgOvKOYxQ3AMBwLDoFAABMRtYBAACmI+84RnEDAAzH9Q8AAJiMrAMAAExH3nGMNTcAAAAAAAAAAIBXYeYGAJiO8j4AADAZWQcAAJiOvOMQxQ0AMByLTgEAAJORdQAAgOnIO45R3AAAw7HoFAAAMBlZBwAAmI684xhrbgAAAAAAAAAAAK/CzA0AMBzFfQAAYDKyDgAAMB15xzGKGwBgOq6AAADAZGQdAABgOvKOQxQ3AMBwLDoFAABMRtYBAACmI+84xpobAGA4i6XqW0UdOXJEVqtV+/fvt+3bs2ePoqOj1aBBA40dO1ZlZWW2ti1btqhNmzYKDQ3V1KlT7Y61atUqNW3aVOHh4Vq+fLld26xZsxQWFqbmzZtr48aNFe8oAADwemQdAABgOlfnHW/JOhQ3AABOdeTIEfXr18/uAlhSUqL4+HhFRUVpx44dysrK0uLFiyVJeXl5SkhIUFJSkjIyMrRs2TJt2rRJ0tkL55AhQzRhwgStX79eqampys7OliStX79eY8aM0bx587R06VIlJycrPz/f1acLAABqGLIOAAAwmTdlHYobAGA4ixO2ihg8eLDuuusuu33vvPOOCgsLNXXqVLVo0UITJ07UwoULJUnLli1TeHi4JkyYoMjISKWmptraFixYoB49eig5OVnt2rXTiBEjtGTJEknSnDlzdO+99yoxMVHdunVTYmKi1qxZU+HvBwAAeDeyDgAAMJ0r8443ZR2KGwBgOidcAUtKSlRUVGS3lZSUOPy4+fPna+TIkXb7MjMz1bVrV9WpU0eS1L59e2VlZdnaevToIcv/5kh26dJFO3futLX17NnTdpzytgEAgBqErAMAAEznwrzjTVmH4gYAGM7ihH9paWmqV6+e3ZaWlubw86xW63n7ioqK7PZbLBb5+vqqoKDgvLbg4GAdPHjQ4fvK2wYAAGoOsg4AADCdK/OON2Udvwq9GgBQI6WkpOiRRx6x2+fv71/u9/v5+Z33+oCAAB0/fvy8tnP7Hb2vvG0AAAAVQdYBAACmq0re8dSsQ3EDAAxnqeiDpB3w9/ev0B/4vxUSEqI9e/bY7Tt69Khq166tkJAQ5eXlnbf/3Psq0wYAAGoOsg4AADCdu/OOp2YdHksFAIZz9SKbjkRHRysjI8P2c05OjkpKShQSEnJe265duxQREeHwfeVtAwAANQdZBwAAmM7decdTsw7FDQAwnMVS9a2qunfvrqKiIi1atEiSNHHiRPXq1Uu+vr5KSEjQtm3btGHDBp0+fVqTJ09W7969JUkDBw7UihUrtHv3bhUXF2vGjBm2tkGDBmn27NnKzc3V4cOHtXDhQlsbAACoOcg6AADAdO7OO56adSxlZWVlVTu1qjl5xp2fDgCeJ8DJDww8UFBS5WM0blDxaYsWi0U5OTlq1qyZJCk9PV1JSUkKDAyUj4+PNm/erLZt20qS5s6dq5EjRyooKEj169dXRkaGwsLCJEnjxo3TlClTFBAQoMjISG3dulWBgYEqKyvTPffco9WrV0uS4uLilJ6eLosz7lAATkTWAQB7ZB2yDsxC1gEAe87OOpJ78o43ZB2KGwDgYZz/B/+pKh+jcQPnPN/50KFD2rlzp7p27aqGDRvateXk5Gjv3r2KiYlRUFCQXVtWVpZyc3MVGxt73vMXt2/frmPHjik2NpY/9uGRyDoAYI+sQ9aBWcg6AGCveoobnpF3PC3rUNwAAA/j7Itg7s9VvwBG1GfxSqCyyDoAYI+sA5iFrAMA9qqjuEHecawavmoAgCdhfB8AADAZWQcAAJiOvOMYC4oDAAAAAAAAAACvwswNADAcj2YGAAAmI+sAAADTkXcco7gBAIazMHkRAAAYjKwDAABMR95xjOIGAJiO6x8AADAZWQcAAJiOvOMQa24AAAAAAAAAAACvwswNADAcxX0AAGAysg4AADAdeccxihsAYDgWnQIAACYj6wAAANORdxyjuAEAhmPRKQAAYDKyDgAAMB15xzHW3AAAAAAAAAAAAF6FmRsAYDqK+wAAwGRkHQAAYDryjkMUNwDAcFz/AACAycg6AADAdOQdxyhuAIDhWHQKAACYjKwDAABMR95xjDU3AAAAAAAAAACAV2HmBgAYzsLkRQAAYDCyDgAAMB15xzGKGwBgOKYuAgAAk5F1AACA6cg7jvFYKgAAAAAAAAAA4FUobgAAAAAAAAAAAK/CY6kAwHBMXQQAACYj6wAAANORdxyjuAEAhmPRKQAAYDKyDgAAMB15xzGKGwBgOKr7AADAZGQdAABgOvKOY6y5AQAAAAAAAAAAvAozNwDAcBT3AQCAycg6AADAdOQdxyhuAIDpuAICAACTkXUAAIDpyDsOUdwAAMOx6BQAADAZWQcAAJiOvOMYa24AAAAAAAAAAACvwswNADCcheI+AAAwGFkHAACYjrzjGMUNADAc1z8AAGAysg4AADAdeccxihsAYDqugAAAwGRkHQAAYDryjkOsuQEAAAAAAAAAALwKMzcAwHAWyvsAAMBgZB0AAGA68o5jFDcAwHAsOgUAAExG1gEAAKYj7zhmKSsrK3N3J1B5JSUlSktLU0pKivz9/d3dHdRg/C4CAKoD1xd4En4fAQDOxrUFnoTfR3gbihterqioSPXq1VNhYaGCg4Pd3R3UYPwuAgCqA9cXeBJ+HwEAzsa1BZ6E30d4GxYUBwAAAAAAAAAAXoXiBgAAAAAAAAAA8CoUNwAAAAAAAAAAgFehuOHl/P399fjjj7PID9yO30UAQHXg+gJPwu8jAMDZuLbAk/D7CG/DguIAAAAAAAAAAMCrMHMDAAAAAAAAAAB4FYobAAAAAAAAAADAq1DcAAAAAAAAAAAAXoXiBgCnOHLkiKxWq/bv3+/urgAAADgdWQcAAJiMrANvRHHDi+3Zs0fR0dFq0KCBxo4dK9aGh7scOXJE/fr14wIIAHAqsg48BVkHAFAdyDrwFGQdeCuKG16qpKRE8fHxioqK0o4dO5SVlaXFixe7u1uooQYPHqy77rrL3d0AABiErANPQtYBADgbWQeehKwDb2Upoyzsld5880398Y9/1IEDB1SnTh1lZmbqz3/+sz766CN3dw01UE5OjqxWqywWi3JyctSsWTN3dwkA4OXIOvAkZB0AgLORdeBJyDrwVszc8FKZmZnq2rWr6tSpI0lq3769srKy3Nwr1FRWq9XdXQAAGIasA09C1gEAOBtZB56ErANvRXHDSxUVFdn9x2OxWOTr66uCggI39goAAMA5yDoAAMBkZB0AqDqKG17Kz89P/v7+dvsCAgJ0/PhxN/UIAADAecg6AADAZGQdAKg6ihteKiQkRHl5eXb7jh49qtq1a7upRwAAAM5D1gEAACYj6wBA1VHc8FLR0dHKyMiw/ZyTk6OSkhKFhIS4sVcAAADOQdYBAAAmI+sAQNVR3PBS3bt3V1FRkRYtWiRJmjhxonr16iVfX1839wwAAKDqyDoAAMBkZB0AqDpLWVlZmbs7gcpJT09XUlKSAgMD5ePjo82bN6tt27bu7hYAAIBTkHUAAIDJyDoAUDUUN7zcoUOHtHPnTnXt2lUNGzZ0d3cAAACciqwDAABMRtYBgMqjuAEAAAAAAAAAALwKa24AAAAAAAAAAACvQnEDAAAAAAAAAAB4FYobAAAAAAAAAADAq1DcAAAAAAAAAAAAXoXiBgAAAAAAAAAA8CoUNwAAAAAAAAAAgFehuAEAAAAAAAAAALwKxQ0AAAAAAAAAAOBVKG4AAAAAAAAAAACv8n93KrIr7HYIYgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred_proba_os = lr_os.predict_proba(X_test.values)\n", + "\n", + "j = 1\n", + "fig = plt.figure(figsize=(20, 15))\n", + "\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall_os = y_pred_proba_os[:, 1] > i\n", + "\n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + "\n", + " cm = confusion_matrix(\n", + " y_test, y_test_predictions_high_recall_os)\n", + "\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + " plt.title(f'Threshold >= {i:.1f}')\n", + "\n", + "# 调整子图之间的间距\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.4)\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/AI/01-\351\200\273\350\276\221\345\233\236\345\275\222\346\250\241\345\236\213-\344\277\241\347\224\250\345\215\241\346\254\272\350\257\210-2.ipynb" "b/python/old-note-py-pyData/AI/01-\351\200\273\350\276\221\345\233\236\345\275\222\346\250\241\345\236\213-\344\277\241\347\224\250\345\215\241\346\254\272\350\257\210-2.ipynb" new file mode 100644 index 0000000..57993c1 --- /dev/null +++ "b/python/old-note-py-pyData/AI/01-\351\200\273\350\276\221\345\233\236\345\275\222\346\250\241\345\236\213-\344\277\241\347\224\250\345\215\241\346\254\272\350\257\210-2.ipynb" @@ -0,0 +1,1791 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 相关概念\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "样本不均匀的解决方法:\n", + " - 下采样\n", + " - 过采样\n", + "\n", + "一份数据一般划分为三部分: \n", + " - 训练集(train): 用于训练模型的参数\n", + " - 验证集(valid): 用于评估模型性能和调优超参数\n", + " - 测试集(test): 评估模型最终的泛化能力\n", + " 注意, 其中的测试集, 可以认为是 \"未来\" 的数据。 我们训练一个模型, 为的就是让他能够对未知的数据进行预测。 \n", + " \n", + "K 折交叉验证的过程一般是这样的:\n", + " 1. 将原始数据集划分为 K 份\n", + " 2. 选取第 i 份作为测试集\n", + " 3. 除了第 i 份数据, 将剩余数据划分为训练集和验证集\n", + " 4. 开始训练, 得到一个模型和一次验证结果\n", + " 5. 总共会重复 k 次重复步骤 2-4。\n", + " 6. 最终可以得到 K 个模型和 K 次验证结果，最终将这些结果取平均值作为模型的性能指标。 \n", + " 注意: K 折交叉验证, 每次训练, 测试集都是不一样的。\n", + "\n", + "交叉验证:\n", + " 除了 K 折交叉验证外, 还有其他类型的交叉验证, 比如:\n", + " - Leave-One-Out(LOO): 留一法交叉验证。 即先从数据集中单独取出测试集, 然后再对剩下的数据划分为 K 折, 每折中再对数据划分为训练集和验证集\n", + " - 嵌套交叉验证的变体: 将数据分为 k 份, 然后在每份数据中再将数据分为 3 份: 训练、验证和测试\n", + " - 嵌套交叉验证: 相当于嵌套 K 折交叉验证, 先将数据划分为 K 份, 每次选取其中一份作为测试集, 此时对剩下的数据再做一次 K 折交叉验证。\n", + " - ... 其他 \n", + " LOO 可以提供更准确的性能评估指标, 但它的计算成本较高, 当数据量非常少的时候, LOO 可能比 K 折交叉验证更合适。 \n", + " 当数据量足够大时, 嵌套交叉可以提供更准确的模型性能评估, 它也要求更高的计算资源。\n", + " 总的来说, 从计算成本和可靠性的角度来看, 通常认为k折交叉验证是更好的选择。\n", + " \n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "TP, TN, FP, FN\n", + " T 和 F 指的是 True, False。 即预测的结果是否正确。\n", + " P 和 N 指的是 Positive, Negative。 P 指的是与我们的目标相符, N 指的与我们的目标不符。 比如检测癌症, 我们的目标就是检测出癌症, 如果检测为没有癌症, 则是 N\n", + " 所以可以这样理解比较方便, 先看是 P 还是 N, 然后再看是对还是错。 \n", + " 下面举多几个例子方便理解:\n", + " - 信用卡欺诈, 我们的 P 是找到欺诈的信用卡。 \n", + " - TP 就是判定为欺诈, 并且判断对了; \n", + " - TN 就是判断为不是欺诈, 结果判定对了; \n", + " - FP 就是判断我欺诈, 结果判断错了;\n", + " - FN 就是判断为不是欺诈, 结果判断错了;\n", + " - 癌症检测, 我们的 P 是检测出癌症\n", + " - TP 就是检测为癌症, 并且检测对了;\n", + " - TN 就是认为没有癌症, 并且确实没有癌症;\n", + " - FP 就是检测为癌症, 但是检测错了;\n", + " - FN 就是认为没有癌症, 但实际上有癌症;\n", + " - 找出狼人, 我们的 P 是找出狼人\n", + " - TP 就是判断为狼人, 并且判断对了;\n", + " - TN 就是判断为平民, 并且判断对了;\n", + " - FP 就是判断为狼人, 但是判断错了。即把平民误判为狼人;\n", + " - FN 就出判断为平民, 但是判断错了。即把狼人错当成平民;\n", + " 这些在实际生活中有什么作用呢? 那就是看需求了, 是要\"宁可错杀一万, 也不放过一个\"呢, 还是要\"疑罪从无\"呢?\n", + " 比如信用卡欺诈, 如果 FP 太大, 则说明误判为欺诈的用户过多, 这可能导致大量用户的账户被冻结, 这是不允许的。\n", + " 所以即使 recall 分数很高, 但如果 FP 太大, 也是不可取的\n", + "\n", + "\n", + "混淆矩阵: 在这里其实指的就是 TP, TN, FP, FN 的可视化结果:\n", + "\n", + " TN FN\n", + " FP TP\n", + "\n", + "模型的度量指标: 常见的有下面几种:\n", + " - 准确率(precision): 预测为该类别的样本数与实际属于该类别的样本数之比。 即 precision = (TP+TN) / (TP+TN+FP+FN); \n", + " $$precision = \\frac{TP+TN}{TP+TN+FP+FN}$$\n", + " - 召回率(recall): 被正确预测为该类别的样本数与实际属于该类别的样本数之比。 即 Recall = TP / (TP + FP); \n", + " $$Recall = \\frac{TP}{TP + FP}$$\n", + " - F1_score: 准确率和召回率的加权平均值。 即 F1_score = 2 * ((precision * recall) / (precision + recall)); \n", + " $$F1\\_score = 2 * \\frac{(precision * recall)}{(precision + recall)}$$\n", + " - 支持度(support): 实际属于该类别的样本数。 即 support = TP + FN; \n", + " $$support = TP + FN$$\n", + "\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "\n", + "\n", + "正则化惩罚项\n", + " loss 是损失函数, loss 越小, 代表效果越好。\n", + " 那么惩罚的方法, 就是让 loss 加上一个值。 比如, 千米跑时, 用时肯定越低越好。 当我们惩罚某人时, 可以让他加上配重跑步, 此时用时就会变大了, 如果负重跑步成绩还非常好的话, 说明它确实很好。\n", + " 这个配重, 就是惩罚项。 比如 L2 的配重就是 0.5w平方; \n", + " L1 惩罚, 就是 w的绝对值\n", + " 但惩罚也是有强度的, 即要给人加上几个配重, 这个值就是 $\\lambda$\n", + "\n", + " scikit-learn 中的 LogisticRegression() 函数, 它的参数叫做 `C`, 这个 c 字母没有具体意义(全称), 可以说它的命名有点随意。 但它表示的是正则化强度的倒数\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "plt.rcParams['font.family'] = ['SimHei']" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 先观察分析数据" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TimeV1V2V3V4V5V6V7V8V9...V21V22V23V24V25V26V27V28AmountClass
00.0-1.359807-0.0727812.5363471.378155-0.3383210.4623880.2395990.0986980.363787...-0.0183070.277838-0.1104740.0669280.128539-0.1891150.133558-0.021053149.620
10.01.1918570.2661510.1664800.4481540.060018-0.082361-0.0788030.085102-0.255425...-0.225775-0.6386720.101288-0.3398460.1671700.125895-0.0089830.0147242.690
21.0-1.358354-1.3401631.7732090.379780-0.5031981.8004990.7914610.247676-1.514654...0.2479980.7716790.909412-0.689281-0.327642-0.139097-0.055353-0.059752378.660
31.0-0.966272-0.1852261.792993-0.863291-0.0103091.2472030.2376090.377436-1.387024...-0.1083000.005274-0.190321-1.1755750.647376-0.2219290.0627230.061458123.500
42.0-1.1582330.8777371.5487180.403034-0.4071930.0959210.592941-0.2705330.817739...-0.0094310.798278-0.1374580.141267-0.2060100.5022920.2194220.21515369.990
\n", + "

5 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " Time V1 V2 V3 V4 V5 V6 V7 \\\n", + "0 0.0 -1.359807 -0.072781 2.536347 1.378155 -0.338321 0.462388 0.239599 \n", + "1 0.0 1.191857 0.266151 0.166480 0.448154 0.060018 -0.082361 -0.078803 \n", + "2 1.0 -1.358354 -1.340163 1.773209 0.379780 -0.503198 1.800499 0.791461 \n", + "3 1.0 -0.966272 -0.185226 1.792993 -0.863291 -0.010309 1.247203 0.237609 \n", + "4 2.0 -1.158233 0.877737 1.548718 0.403034 -0.407193 0.095921 0.592941 \n", + "\n", + " V8 V9 ... V21 V22 V23 V24 V25 \\\n", + "0 0.098698 0.363787 ... -0.018307 0.277838 -0.110474 0.066928 0.128539 \n", + "1 0.085102 -0.255425 ... -0.225775 -0.638672 0.101288 -0.339846 0.167170 \n", + "2 0.247676 -1.514654 ... 0.247998 0.771679 0.909412 -0.689281 -0.327642 \n", + "3 0.377436 -1.387024 ... -0.108300 0.005274 -0.190321 -1.175575 0.647376 \n", + "4 -0.270533 0.817739 ... -0.009431 0.798278 -0.137458 0.141267 -0.206010 \n", + "\n", + " V26 V27 V28 Amount Class \n", + "0 -0.189115 0.133558 -0.021053 149.62 0 \n", + "1 0.125895 -0.008983 0.014724 2.69 0 \n", + "2 -0.139097 -0.055353 -0.059752 378.66 0 \n", + "3 -0.221929 0.062723 0.061458 123.50 0 \n", + "4 0.502292 0.219422 0.215153 69.99 0 \n", + "\n", + "[5 rows x 31 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = pd.read_csv('./resource/creditcard.csv')\n", + "data.head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "观察数据, Time 是没有价值的。 故后面我们会将该列删去。\n", + "\n", + "这些数据是信用卡原数据经过脱敏, 降维处理过的, 其中的 V1 ~ V28, Amount 都是特征, 故我们不需要再提取特征。\n", + "\n", + "Amount 的值相对其他特征来说, 数值偏大, 区间跨区也大。\n", + "反观其他特征 V, 基本都是 -1 到 1 左右, 数值较小, 区间也不大。\n", + "并且, 我们并不知道哪些特征的权重(重要程度)较大, 所以为了让每一个特征的权重都尽可能相同, \n", + "我们后面需要对 Amount 进行标准化处理。（不然模型可能会认为, Amount 重要程度也其他特征大）\n", + "\n", + "容易看出, Class 应该就是标签了(因为我们这是一个分类问题)。 具体情况后面再分析。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 数据预处理" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 对 Amount 进行数据缩放\n", + "\n", + "先对 Amount 进行一个标准化, 目的是为了让每个特征的权重基本相同。\n", + "\n", + "归一化是数据缩放的一种方式, 标准化是归一化的一种。\n", + "标准化的做法是将数据转换为均值为 0, 方差为 1 的标准正态分布。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.244964\n", + "1 -0.342475\n", + "2 1.160686\n", + "3 0.140534\n", + "4 -0.073403\n", + "Name: normAmount, dtype: float64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# 将 Amount 列(Series)提取出来，转换为 NumPy 数组, 并 reshape 成一个列向量。 -1 表示让其自动计算\n", + "amount = np.array(data['Amount']).reshape(-1, 1) \n", + "# 标准化\n", + "data['normAmount'] = StandardScaler().fit_transform(amount)\n", + "data['normAmount'].head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 删除一些不必要的列" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
V1V2V3V4V5V6V7V8V9V10...V21V22V23V24V25V26V27V28ClassnormAmount
0-1.359807-0.0727812.5363471.378155-0.3383210.4623880.2395990.0986980.3637870.090794...-0.0183070.277838-0.1104740.0669280.128539-0.1891150.133558-0.02105300.244964
11.1918570.2661510.1664800.4481540.060018-0.082361-0.0788030.085102-0.255425-0.166974...-0.225775-0.6386720.101288-0.3398460.1671700.125895-0.0089830.0147240-0.342475
2-1.358354-1.3401631.7732090.379780-0.5031981.8004990.7914610.247676-1.5146540.207643...0.2479980.7716790.909412-0.689281-0.327642-0.139097-0.055353-0.05975201.160686
3-0.966272-0.1852261.792993-0.863291-0.0103091.2472030.2376090.377436-1.387024-0.054952...-0.1083000.005274-0.190321-1.1755750.647376-0.2219290.0627230.06145800.140534
4-1.1582330.8777371.5487180.403034-0.4071930.0959210.592941-0.2705330.8177390.753074...-0.0094310.798278-0.1374580.141267-0.2060100.5022920.2194220.2151530-0.073403
\n", + "

5 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " V1 V2 V3 V4 V5 V6 V7 \\\n", + "0 -1.359807 -0.072781 2.536347 1.378155 -0.338321 0.462388 0.239599 \n", + "1 1.191857 0.266151 0.166480 0.448154 0.060018 -0.082361 -0.078803 \n", + "2 -1.358354 -1.340163 1.773209 0.379780 -0.503198 1.800499 0.791461 \n", + "3 -0.966272 -0.185226 1.792993 -0.863291 -0.010309 1.247203 0.237609 \n", + "4 -1.158233 0.877737 1.548718 0.403034 -0.407193 0.095921 0.592941 \n", + "\n", + " V8 V9 V10 ... V21 V22 V23 V24 \\\n", + "0 0.098698 0.363787 0.090794 ... -0.018307 0.277838 -0.110474 0.066928 \n", + "1 0.085102 -0.255425 -0.166974 ... -0.225775 -0.638672 0.101288 -0.339846 \n", + "2 0.247676 -1.514654 0.207643 ... 0.247998 0.771679 0.909412 -0.689281 \n", + "3 0.377436 -1.387024 -0.054952 ... -0.108300 0.005274 -0.190321 -1.175575 \n", + "4 -0.270533 0.817739 0.753074 ... -0.009431 0.798278 -0.137458 0.141267 \n", + "\n", + " V25 V26 V27 V28 Class normAmount \n", + "0 0.128539 -0.189115 0.133558 -0.021053 0 0.244964 \n", + "1 0.167170 0.125895 -0.008983 0.014724 0 -0.342475 \n", + "2 -0.327642 -0.139097 -0.055353 -0.059752 0 1.160686 \n", + "3 0.647376 -0.221929 0.062723 0.061458 0 0.140534 \n", + "4 -0.206010 0.502292 0.219422 0.215153 0 -0.073403 \n", + "\n", + "[5 rows x 30 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# axis=1 表示按列操作(删除)\n", + "data = data.drop(['Time', 'Amount'], axis=1)\n", + "data.head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 观察 Class\n", + "Class 就是标签, 即该信用卡是否是欺诈的。 我们先看看 Class 中值的分布" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[284315 492]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 对 Class 列进行值计数, 统计不同值出现的次数。 并将这些\"不同值\"作为索引, \"次数\" 作为值, 返回成一个 Series 对象\n", + "count_classes = pd.value_counts( data['Class'], sort=True ).sort_index()\n", + "\n", + "# 绘制柱形图\n", + "ax = count_classes.plot(kind = 'bar', rot=0)\n", + "\n", + "# 在柱形上添加数值标签\n", + "for p in ax.containers:\n", + " ax.bar_label(p, fontsize=14)\n", + "\n", + "plt.title('Class 标签的柱状统计图')\n", + "plt.xlabel('Class 标签值')\n", + "plt.ylabel('出现次数')\n", + "\n", + "print(count_classes.values)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "观察发现, Class 中值为 1 的比例非常低, 现实中欺诈的信用卡比例也是很低的, 所以 1 表示应该是异常样本(欺诈), 0 表示的应该就是正常样本。\n", + "\n", + "样本数量不均匀的情况下, 我们一般有两种处理方式： 过采样和下采样。\n", + "\n", + "为什么样本数分布不均匀要进行处理呢? 举个例子, 假如有 10,000 人, 里面有 9,900 人是正常的, 100 人是癌症。\n", + "这种情况下, 你训练模型, 那么模型会发现, 猜每个人都是正常的, 准确率能达到了 99%。\n", + "这样一来, 当你实际应用模型时, 默认对于任何人, 都认为他是正常的。\n", + "这样的模型是没有意义的。 所以训练模型时, 需要对样本分布不均匀的数据进行处理。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 对原始数据划分训练集和测试集" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "这里划分出的测试集, 将用于后面三种模型(不处理, 下采样, 过采样)的测试。\n", + "\n", + "后面的下采样, 过采样, 将是基于这里划分出的训练集。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$\\mathbf{X}$ 是特征矩阵\n", + "\n", + "$\\mathbf{y}$ 是标签向量" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原始数据集划分\n", + "\t训练数据集数量: 199364\n", + "\t测试数据集数量: 85443\n", + "\t总数据集数量: 284807\n" + ] + }, + { + "data": { + "text/plain": [ + "(199364, 30)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_origin = data.loc[:, data.columns != 'Class']\n", + "y_origin = data.loc[:, data.columns == 'Class']\n", + "\n", + "# random_state=42 是为了让每次随机划分的结果相同\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X_origin, y_origin, test_size=0.3, random_state=42)\n", + "print('原始数据集划分')\n", + "print('\\t训练数据集数量: ', len(X_train))\n", + "print('\\t测试数据集数量: ', len(X_test))\n", + "print('\\t总数据集数量: ', len(X_train) + len(X_test))\n", + "\n", + "train_data = pd.concat([X_train, y_train], axis=1)\n", + "train_data.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. 执行下采样生成的数据集" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下采样: \n", + " 比如 A, B 两类, A 类的样本数有 10,000; B 类样本数只有 100; \n", + " 下采样就是从 A 类样本中随机抽取和B类样本数相同的样本, 即 100 个样本,\n", + " 然后将从 A 类中随机取出的样本和 B 类的样本组成成新的数据集。\n", + " 这样新的数据集中 A, B 两类的分布就均匀了。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原始样本的分布: [199008 356]\n", + "下采样后样本的分布: [356 356]\n" + ] + }, + { + "data": { + "text/plain": [ + "((712, 29), (712, 1))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 欺诈样本\n", + "fraud_data = train_data[train_data.Class == 1]\n", + "# 正常样本\n", + "normal_data = train_data[train_data.Class == 0]\n", + "# 从正常样本中随机抽取盒欺诈样本数量相同的样本\n", + "random_normal_data = normal_data.sample(n=len(fraud_data), random_state=42)\n", + "\n", + "# 合并欺诈样本和随机选取的正常样本\n", + "undersampled_data = pd.concat([fraud_data, random_normal_data], axis=0).sample(frac=1) # sample(frac=1) 用于打乱顺序\n", + "\n", + "X_undersampled = undersampled_data.loc[:, undersampled_data.columns != 'Class']\n", + "y_undersampled = undersampled_data.loc[:, undersampled_data.columns == 'Class']\n", + "\n", + "print('原始样本的分布: ', train_data.groupby('Class').size().values)\n", + "print('下采样后样本的分布: ', undersampled_data.groupby('Class').size().values)\n", + "\n", + "X_undersampled.shape, y_undersampled.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. 执行过采样生成的数据集" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from imblearn.over_sampling import SMOTE # pip install imblearn\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((278611, 29), (278611, 1))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 使用SMOTE进行过采样\n", + "smote = SMOTE(random_state=0)\n", + "# 有时也会命名为 X_resampled, y_resampled\n", + "X_over_sample, y_over_sample = smote.fit_resample(X_train, y_train)\n", + "\n", + "X_oversampled, X_train_over_sample, y_oversampled, y_test_over_sample = train_test_split(\n", + " X_over_sample, y_over_sample, test_size=0.3, random_state=42)\n", + "\n", + "\n", + "X_oversampled.shape, y_oversampled.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. 不执行过采样和下采样的数据集" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((199364, 29), (199364, 1))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X, y = X_train, y_train\n", + "\n", + "X.shape, y.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. 训练模型, 求取最优参数 c" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import KFold, cross_val_score\n", + "from sklearn.metrics import make_scorer, recall_score, confusion_matrix, classification_report\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "求取最优参数 C\n", + "\n", + "K 折交叉验算" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def printing_KFold_scores(X_train_data, y_train_data):\n", + "\n", + " # 这个是正则化惩罚项参数.\n", + " c_param_range = [0.001, 0.01, 0.1, 1, 10]\n", + "\n", + " # K 折\n", + " K = 5\n", + "\n", + " # 创建一个表格存储分数\n", + " original_columns = ['C_parameter', 'Mean recall scores']\n", + " new_columns = [f'score-{i}' for i in range(1, K+1)]\n", + " result_columns = original_columns[:1] + new_columns + original_columns[1:]\n", + " results_table = pd.DataFrame(columns=result_columns)\n", + " j = 0\n", + "\n", + " # 这个循环用来查看哪个 c 参数效果好\n", + " for c_param in c_param_range:\n", + "\n", + " # 创建逻辑回归分类器\n", + " logreg = LogisticRegression(C=c_param, penalty='l2')\n", + "\n", + " # 创建KFold对象\n", + " kfold = KFold(n_splits=K, shuffle=False)\n", + "\n", + " # 创建recall_score评分器\n", + " scorer = make_scorer(recall_score, average='macro')\n", + "\n", + " # 使用交叉验证计算模型的精度\n", + " scores = cross_val_score(\n", + " logreg, X_train_data.values, y_train_data.values.flatten(), cv=kfold, scoring=scorer)\n", + "\n", + " row = pd.Series(\n", + " {'score-' + str(i+1): f'{scores[i]:.3f}' for i in range(len(scores))})\n", + " results_table = pd.concat(\n", + " [results_table, row.to_frame().T], ignore_index=True)\n", + " results_table.loc[j, 'C_parameter'] = c_param\n", + " results_table.loc[j, 'Mean recall scores'] = float(scores.mean())\n", + " j += 1\n", + "\n", + " i_max = results_table['Mean recall scores'].astype(float).idxmax()\n", + " best_score = results_table.loc[i_max, 'Mean recall scores']\n", + " best_c_parameter = results_table.loc[i_max, 'C_parameter']\n", + " \n", + " return best_c_parameter, best_score, results_table\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "原始数据作为训练集训练模型" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best_c: 1;\n", + "best_scores: 0.8073968271739753;\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
C_parameterscore-1score-2score-3score-4score-5Mean recall scores
00.0010.7530.7240.7500.7470.7850.75167
10.010.7850.7590.8190.7600.8260.78979
20.10.7850.7760.8260.7670.8540.801509
310.7850.7840.8330.7670.8680.807397
4100.7850.7840.8330.7670.8680.807394
\n", + "
" + ], + "text/plain": [ + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 0.001 0.753 0.724 0.750 0.747 0.785 0.75167\n", + "1 0.01 0.785 0.759 0.819 0.760 0.826 0.78979\n", + "2 0.1 0.785 0.776 0.826 0.767 0.854 0.801509\n", + "3 1 0.785 0.784 0.833 0.767 0.868 0.807397\n", + "4 10 0.785 0.784 0.833 0.767 0.868 0.807394" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_c, best_scores, scores_table = printing_KFold_scores(X, y)\n", + "print(f'best_c: {best_c};')\n", + "print(f'best_scores: {best_scores};')\n", + "scores_table" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下采样数据集作为训练集训练模型" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best_c_us: 1;\n", + "best_scores_us: 0.9372533157678837;\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Linhieng\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\linear_model\\_logistic.py:444: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
C_parameterscore-1score-2score-3score-4score-5Mean recall scores
00.0010.9430.9070.9020.9010.8780.906242
10.010.9570.9220.9240.9260.9050.92677
20.10.9510.9360.9200.9170.9110.926916
310.9510.9370.9360.9390.9240.937253
4100.9510.9370.9360.9300.9240.93542
\n", + "
" + ], + "text/plain": [ + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 0.001 0.943 0.907 0.902 0.901 0.878 0.906242\n", + "1 0.01 0.957 0.922 0.924 0.926 0.905 0.92677\n", + "2 0.1 0.951 0.936 0.920 0.917 0.911 0.926916\n", + "3 1 0.951 0.937 0.936 0.939 0.924 0.937253\n", + "4 10 0.951 0.937 0.936 0.930 0.924 0.93542" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_c_us, best_scores_us, scores_table_us = printing_KFold_scores(X_undersampled, y_undersampled)\n", + "print(f'best_c_us: {best_c_us};')\n", + "print(f'best_scores_us: {best_scores_us};')\n", + "scores_table_us" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "过采样数据集作为训练集训练模型" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Linhieng\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\linear_model\\_logistic.py:444: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best_c_os: 10;\n", + "best_scores_os: 0.9454796729774951;\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
C_parameterscore-1score-2score-3score-4score-5Mean recall scores
00.0010.9420.9430.9440.9430.9410.942622
10.010.9450.9440.9460.9450.9430.94455
20.10.9460.9450.9470.9460.9430.945372
310.9460.9450.9470.9460.9440.945476
4100.9460.9450.9470.9460.9440.94548
\n", + "
" + ], + "text/plain": [ + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 0.001 0.942 0.943 0.944 0.943 0.941 0.942622\n", + "1 0.01 0.945 0.944 0.946 0.945 0.943 0.94455\n", + "2 0.1 0.946 0.945 0.947 0.946 0.943 0.945372\n", + "3 1 0.946 0.945 0.947 0.946 0.944 0.945476\n", + "4 10 0.946 0.945 0.947 0.946 0.944 0.94548" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_c_os, best_scores_os, scores_table_os = printing_KFold_scores(X_oversampled, y_oversampled)\n", + "print(f'best_c_os: {best_c_os};')\n", + "print(f'best_scores_os: {best_scores_os};')\n", + "scores_table_os" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. 应用到测试集查看效果" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import plot_confusion_matrix\n", + "import seaborn as sns\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "默认数据集训练出来的模型" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 85307\n", + " 1 0.88 0.62 0.73 136\n", + "\n", + " accuracy 1.00 85443\n", + " macro avg 0.94 0.81 0.86 85443\n", + "weighted avg 1.00 1.00 1.00 85443\n", + "\n" + ] + } + ], + "source": [ + "# 使用前面求出的最优参数 c 训练模型\n", + "lr = LogisticRegression(C=best_c, penalty='l2')\n", + "lr.fit(X.values, y.values.flatten())\n", + "\n", + "# 测试模型\n", + "y_pred = lr.predict(X_test.values)\n", + "\n", + "# 计算混淆矩阵\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "\n", + "# 可视化混淆矩阵\n", + "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + "plt.title('混淆矩阵 - 原始数据的训练模型')\n", + "plt.show()\n", + "\n", + "# 生成分类指标报告\n", + "report = classification_report(y_test, y_pred)\n", + "\n", + "# 打印报告\n", + "print(report)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下采样数据集训练出来的模型" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.96 0.98 85307\n", + " 1 0.04 0.93 0.07 136\n", + "\n", + " accuracy 0.96 85443\n", + " macro avg 0.52 0.95 0.53 85443\n", + "weighted avg 1.00 0.96 0.98 85443\n", + "\n" + ] + } + ], + "source": [ + "# 使用下采样数据集和下采样数据集的最优参数 c 训练模型\n", + "lr_us = LogisticRegression(C=best_c_us, penalty='l2')\n", + "lr_us.fit(X_undersampled.values, y_undersampled.values.flatten())\n", + "\n", + "# 测试模型使用的应该是同一套测试集\n", + "y_pred_us = lr_us.predict(X_test.values)\n", + "\n", + "# 计算混淆矩阵\n", + "cm_us = confusion_matrix(y_test, y_pred_us)\n", + "\n", + "# 可视化混淆矩阵\n", + "sns.heatmap(cm_us, annot=True, fmt='d', cmap='Blues')\n", + "plt.title('混淆矩阵 - 下采样数据的训练模型')\n", + "plt.show()\n", + "\n", + "# 生成分类指标报告\n", + "report_os = classification_report(y_test, y_pred_us)\n", + "\n", + "# 打印报告\n", + "print(report_os)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "过采样数据集训练出来的模型" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Linhieng\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\linear_model\\_logistic.py:444: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.96 0.98 85307\n", + " 1 0.04 0.93 0.07 136\n", + "\n", + " accuracy 0.96 85443\n", + " macro avg 0.52 0.95 0.53 85443\n", + "weighted avg 1.00 0.96 0.98 85443\n", + "\n" + ] + } + ], + "source": [ + "# 使用下采样数据集和下采样数据集的最优参数 c 训练模型\n", + "lr_os = LogisticRegression(C=best_c_os, penalty='l2')\n", + "lr_os.fit(X_oversampled.values, y_oversampled.values.flatten())\n", + "\n", + "# 测试模型使用的应该是同一套测试集\n", + "y_pred_os = lr_os.predict(X_test.values)\n", + "\n", + "# 计算混淆矩阵\n", + "cm_os = confusion_matrix(y_test, y_pred_os)\n", + "\n", + "# 可视化混淆矩阵\n", + "sns.heatmap(cm_os, annot=True, fmt='d', cmap='Blues')\n", + "plt.title('混淆矩阵 - 过采样数据的训练模型')\n", + "plt.show()\n", + "\n", + "# 生成分类指标报告\n", + "report_os = classification_report(y_test, y_pred_us)\n", + "\n", + "# 打印报告\n", + "print(report_os)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. 查看逻辑回归的阈值对结果的影响" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "thresholds = np.arange(0.1, 1.0, 0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred_proba = lr.predict_proba(X_test.values)\n", + "\n", + "j = 1\n", + "fig = plt.figure(figsize=(20, 15))\n", + "\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall = y_pred_proba[:, 1] > i\n", + "\n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + "\n", + " cm = confusion_matrix(\n", + " y_test, y_test_predictions_high_recall)\n", + "\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + " plt.title(f'Threshold >= {i:.1f}')\n", + "\n", + "# 调整子图之间的间距\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.4)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred_proba_us = lr_us.predict_proba(X_test.values)\n", + "\n", + "j = 1\n", + "fig = plt.figure(figsize=(20, 15))\n", + "\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall_us = y_pred_proba_us[:, 1] > i\n", + "\n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + "\n", + " cm = confusion_matrix(\n", + " y_test, y_test_predictions_high_recall_us)\n", + "\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + " plt.title(f'Threshold >= {i:.1f}')\n", + "\n", + "# 调整子图之间的间距\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.4)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred_proba_os = lr_os.predict_proba(X_test.values)\n", + "\n", + "j = 1\n", + "fig = plt.figure(figsize=(20, 15))\n", + "\n", + "for i in thresholds:\n", + " y_test_predictions_high_recall_os = y_pred_proba_os[:, 1] > i\n", + "\n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + "\n", + " cm = confusion_matrix(\n", + " y_test, y_test_predictions_high_recall_os)\n", + "\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n", + " plt.title(f'Threshold >= {i:.1f}')\n", + "\n", + "# 调整子图之间的间距\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.4)\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/old-note-py-pyData/AI/AI-01.ipynb b/python/old-note-py-pyData/AI/AI-01.ipynb new file mode 100644 index 0000000..1af159e --- /dev/null +++ b/python/old-note-py-pyData/AI/AI-01.ipynb @@ -0,0 +1,44 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 神经网络中的超参数(hyperparameter)\n", + "\n", + "- 学习率: $\\eta$, learning rate, lr\n", + "- 批量大小: $|\\mathcal{B}|$, batch size。 表示每个小批量中的样本数\n", + "- 迭代周期: epochs\n", + "- 正则化参数\n", + " - $\\lambda$, 正则化参数, $L_1$ 或 $L_2$ 正则化强度。 是惩罚项($\\frac{\\lambda}{2} \\|\\mathbf{w}\\|^2$)的系数\n", + " > $$L(\\mathbf{w}, b) + \\frac{\\lambda}{2} \\|\\mathbf{w}\\|^2$$\n", + " - weight_decay, 这个变量代表 权重衰退(weight decay) 的超参数。 权重衰退又被称为 $L_2$ 正则化。 \n", + " > $\\lambda$ 和 weight_decay 有些类似但又不一样。 我的理解是, weight_decay 是权重衰退的超参数的统称; 而 $\\lambda$ 是中惩罚项的系数, 它可以认为是权重衰退的一个超参数。\n", + "- 神经元数量\n", + "- 神经元层数\n", + "- 激活函数。 常见的有 sigmoid、ReLU、tanh\n", + "- 优化器。 SGD、Adam" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`input_dim=2`\n", + "`input_shape=(None, 2)`\n", + "`input_shape=(2,)`\n", + "这三个是等效的。 " + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/old-note-py-pyData/AI/KFlod.ipynb b/python/old-note-py-pyData/AI/KFlod.ipynb new file mode 100644 index 0000000..5875cd9 --- /dev/null +++ b/python/old-note-py-pyData/AI/KFlod.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1\n", + "KFold是一个用于交叉验证的方法，它将数据集随机分为k个互斥的子集（也称为“折叠”），然后对模型进行训练和测试。在交叉验证期间，每个子集都会轮流充当测试集一次，而其余的k-1个子集则作为训练集。这种方法可以帮助我们更准确地评估模型的性能，因为它使用了更多的数据来进行训练和测试。\n", + "\n", + "下面是一个使用KFold实现交叉验证的示例代码：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.93333333 0.93333333 1. 0.96666667 0.96666667]\n" + ] + } + ], + "source": [ + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import KFold, cross_val_score\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "\n", + "# 加载鸢尾花数据集\n", + "iris = load_iris()\n", + "\n", + "# 创建KNN分类器\n", + "knn = KNeighborsClassifier(n_neighbors=5)\n", + "\n", + "# 创建KFold对象\n", + "kfold = KFold(n_splits=5, shuffle=True)\n", + "\n", + "# 使用交叉验证计算模型的精度\n", + "scores = cross_val_score(knn, iris.data, iris.target, cv=kfold)\n", + "\n", + "# 打印精度得分\n", + "print(scores)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在上面的示例中，我们创建了一个包含5个折叠的KFold对象，并将其传递给cross_val_score函数。该函数执行5次训练和测试，并返回一个包含每次测试得分的数组。我们最终打印出所有5次测试得分以及它们的平均值。注意，我们还可以通过设置 shuffle=True 来打乱数据集的顺序以增加模型的泛化能力。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2\n", + "以下是使用LogisticRegression模型和KFold交叉验证计算精度的示例代码：" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.93333333 1. 0.93333333 0.96666667 0.96666667]\n" + ] + } + ], + "source": [ + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import KFold, cross_val_score\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "# 加载鸢尾花数据集\n", + "iris = load_iris()\n", + "\n", + "# 创建逻辑回归分类器\n", + "logreg = LogisticRegression(solver='liblinear', multi_class='auto')\n", + "\n", + "# 创建KFold对象\n", + "kfold = KFold(n_splits=5, shuffle=True)\n", + "\n", + "# 使用交叉验证计算模型的精度\n", + "scores = cross_val_score(logreg, iris.data, iris.target, cv=kfold)\n", + "\n", + "# 打印精度得分\n", + "print(scores)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在这个示例中，我们创建了一个包含5个折叠的KFold对象，将其传递给cross_val_score函数，并使用LogisticRegression模型进行训练和测试。最后，我们打印出所有5次测试得分以及它们的平均值。\n", + "\n", + "请注意，我们在实例化LogisticRegression时指定了solver='liblinear'和multi_class='auto'参数，这是因为默认情况下，scikit-learn会使用不同的求解器（solver）和多类别分类策略（multi-class strategy）对问题进行求解。由于数据集较小且简单，我们可以使用默认设置。但如果您在处理更大、更复杂的数据集时，您可能需要优化这些参数以获得更好的性能。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3\n", + "以下是使用recall_score作为评分指标的示例代码：" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1. 0.96969697 0.85858586 0.93939394 1. ]\n" + ] + } + ], + "source": [ + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import KFold, cross_val_score\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import make_scorer, recall_score\n", + "\n", + "# 加载鸢尾花数据集\n", + "iris = load_iris()\n", + "\n", + "# 创建逻辑回归分类器\n", + "logreg = LogisticRegression(solver='liblinear', multi_class='auto')\n", + "\n", + "# 创建KFold对象\n", + "kfold = KFold(n_splits=5, shuffle=True)\n", + "\n", + "# 创建recall_score评分器\n", + "scorer = make_scorer(recall_score, average='macro')\n", + "\n", + "# 使用交叉验证计算模型的精度\n", + "scores = cross_val_score(logreg, iris.data, iris.target, cv=kfold, scoring=scorer)\n", + "\n", + "# 打印精度得分\n", + "print(scores)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在这个示例中，我们创建了一个包含5个折叠的KFold对象，将其传递给cross_val_score函数，并使用LogisticRegression模型进行训练和测试。我们还使用make_scorer函数创建了一个评分器，它将recall_score作为评分指标，并设置average='macro'来计算每个类别的平均值。最后，我们将评分器传递给cross_val_score函数的scoring参数中以计算所有测试得分的平均值。\n", + "\n", + "请注意，在这个示例中，我们使用make_scorer函数将recall_score转换为一个得分函数，这样才能传递给cross_val_score函数。如果您想使用其他的评分指标，可以将它们转换为得分函数并将它们传递给make_scorer函数即可。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5.1 3.5 1.4 0.2]\n", + " [4.9 3. 1.4 0.2]\n", + " [4.7 3.2 1.3 0.2]\n", + " [4.6 3.1 1.5 0.2]\n", + " [5. 3.6 1.4 0.2]\n", + " [5.4 3.9 1.7 0.4]\n", + " [4.6 3.4 1.4 0.3]\n", + " [5. 3.4 1.5 0.2]\n", + " [4.4 2.9 1.4 0.2]\n", + " [4.9 3.1 1.5 0.1]\n", + " [5.4 3.7 1.5 0.2]\n", + " [4.8 3.4 1.6 0.2]\n", + " [4.8 3. 1.4 0.1]\n", + " [4.3 3. 1.1 0.1]\n", + " [5.8 4. 1.2 0.2]\n", + " [5.7 4.4 1.5 0.4]\n", + " [5.4 3.9 1.3 0.4]\n", + " [5.1 3.5 1.4 0.3]\n", + " [5.7 3.8 1.7 0.3]\n", + " [5.1 3.8 1.5 0.3]\n", + " [5.4 3.4 1.7 0.2]\n", + " [5.1 3.7 1.5 0.4]\n", + " [4.6 3.6 1. 0.2]\n", + " [5.1 3.3 1.7 0.5]\n", + " [4.8 3.4 1.9 0.2]\n", + " [5. 3. 1.6 0.2]\n", + " [5. 3.4 1.6 0.4]\n", + " [5.2 3.5 1.5 0.2]\n", + " [5.2 3.4 1.4 0.2]\n", + " [4.7 3.2 1.6 0.2]\n", + " [4.8 3.1 1.6 0.2]\n", + " [5.4 3.4 1.5 0.4]\n", + " [5.2 4.1 1.5 0.1]\n", + " [5.5 4.2 1.4 0.2]\n", + " [4.9 3.1 1.5 0.2]\n", + " [5. 3.2 1.2 0.2]\n", + " [5.5 3.5 1.3 0.2]\n", + " [4.9 3.6 1.4 0.1]\n", + " [4.4 3. 1.3 0.2]\n", + " [5.1 3.4 1.5 0.2]\n", + " [5. 3.5 1.3 0.3]\n", + " [4.5 2.3 1.3 0.3]\n", + " [4.4 3.2 1.3 0.2]\n", + " [5. 3.5 1.6 0.6]\n", + " [5.1 3.8 1.9 0.4]\n", + " [4.8 3. 1.4 0.3]\n", + " [5.1 3.8 1.6 0.2]\n", + " [4.6 3.2 1.4 0.2]\n", + " [5.3 3.7 1.5 0.2]\n", + " [5. 3.3 1.4 0.2]\n", + " [7. 3.2 4.7 1.4]\n", + " [6.4 3.2 4.5 1.5]\n", + " [6.9 3.1 4.9 1.5]\n", + " [5.5 2.3 4. 1.3]\n", + " [6.5 2.8 4.6 1.5]\n", + " [5.7 2.8 4.5 1.3]\n", + " [6.3 3.3 4.7 1.6]\n", + " [4.9 2.4 3.3 1. ]\n", + " [6.6 2.9 4.6 1.3]\n", + " [5.2 2.7 3.9 1.4]\n", + " [5. 2. 3.5 1. ]\n", + " [5.9 3. 4.2 1.5]\n", + " [6. 2.2 4. 1. ]\n", + " [6.1 2.9 4.7 1.4]\n", + " [5.6 2.9 3.6 1.3]\n", + " [6.7 3.1 4.4 1.4]\n", + " [5.6 3. 4.5 1.5]\n", + " [5.8 2.7 4.1 1. ]\n", + " [6.2 2.2 4.5 1.5]\n", + " [5.6 2.5 3.9 1.1]\n", + " [5.9 3.2 4.8 1.8]\n", + " [6.1 2.8 4. 1.3]\n", + " [6.3 2.5 4.9 1.5]\n", + " [6.1 2.8 4.7 1.2]\n", + " [6.4 2.9 4.3 1.3]\n", + " [6.6 3. 4.4 1.4]\n", + " [6.8 2.8 4.8 1.4]\n", + " [6.7 3. 5. 1.7]\n", + " [6. 2.9 4.5 1.5]\n", + " [5.7 2.6 3.5 1. ]\n", + " [5.5 2.4 3.8 1.1]\n", + " [5.5 2.4 3.7 1. ]\n", + " [5.8 2.7 3.9 1.2]\n", + " [6. 2.7 5.1 1.6]\n", + " [5.4 3. 4.5 1.5]\n", + " [6. 3.4 4.5 1.6]\n", + " [6.7 3.1 4.7 1.5]\n", + " [6.3 2.3 4.4 1.3]\n", + " [5.6 3. 4.1 1.3]\n", + " [5.5 2.5 4. 1.3]\n", + " [5.5 2.6 4.4 1.2]\n", + " [6.1 3. 4.6 1.4]\n", + " [5.8 2.6 4. 1.2]\n", + " [5. 2.3 3.3 1. ]\n", + " [5.6 2.7 4.2 1.3]\n", + " [5.7 3. 4.2 1.2]\n", + " [5.7 2.9 4.2 1.3]\n", + " [6.2 2.9 4.3 1.3]\n", + " [5.1 2.5 3. 1.1]\n", + " [5.7 2.8 4.1 1.3]\n", + " [6.3 3.3 6. 2.5]\n", + " [5.8 2.7 5.1 1.9]\n", + " [7.1 3. 5.9 2.1]\n", + " [6.3 2.9 5.6 1.8]\n", + " [6.5 3. 5.8 2.2]\n", + " [7.6 3. 6.6 2.1]\n", + " [4.9 2.5 4.5 1.7]\n", + " [7.3 2.9 6.3 1.8]\n", + " [6.7 2.5 5.8 1.8]\n", + " [7.2 3.6 6.1 2.5]\n", + " [6.5 3.2 5.1 2. ]\n", + " [6.4 2.7 5.3 1.9]\n", + " [6.8 3. 5.5 2.1]\n", + " [5.7 2.5 5. 2. ]\n", + " [5.8 2.8 5.1 2.4]\n", + " [6.4 3.2 5.3 2.3]\n", + " [6.5 3. 5.5 1.8]\n", + " [7.7 3.8 6.7 2.2]\n", + " [7.7 2.6 6.9 2.3]\n", + " [6. 2.2 5. 1.5]\n", + " [6.9 3.2 5.7 2.3]\n", + " [5.6 2.8 4.9 2. ]\n", + " [7.7 2.8 6.7 2. ]\n", + " [6.3 2.7 4.9 1.8]\n", + " [6.7 3.3 5.7 2.1]\n", + " [7.2 3.2 6. 1.8]\n", + " [6.2 2.8 4.8 1.8]\n", + " [6.1 3. 4.9 1.8]\n", + " [6.4 2.8 5.6 2.1]\n", + " [7.2 3. 5.8 1.6]\n", + " [7.4 2.8 6.1 1.9]\n", + " [7.9 3.8 6.4 2. ]\n", + " [6.4 2.8 5.6 2.2]\n", + " [6.3 2.8 5.1 1.5]\n", + " [6.1 2.6 5.6 1.4]\n", + " [7.7 3. 6.1 2.3]\n", + " [6.3 3.4 5.6 2.4]\n", + " [6.4 3.1 5.5 1.8]\n", + " [6. 3. 4.8 1.8]\n", + " [6.9 3.1 5.4 2.1]\n", + " [6.7 3.1 5.6 2.4]\n", + " [6.9 3.1 5.1 2.3]\n", + " [5.8 2.7 5.1 1.9]\n", + " [6.8 3.2 5.9 2.3]\n", + " [6.7 3.3 5.7 2.5]\n", + " [6.7 3. 5.2 2.3]\n", + " [6.3 2.5 5. 1.9]\n", + " [6.5 3. 5.2 2. ]\n", + " [6.2 3.4 5.4 2.3]\n", + " [5.9 3. 5.1 1.8]]\n" + ] + } + ], + "source": [ + "print(iris.data)\n", + "# print(iris.target)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原始样本数：1000\n", + "过采样后样本数：1800\n" + ] + } + ], + "source": [ + "from imblearn.over_sampling import SMOTE\n", + "from sklearn.datasets import make_classification\n", + "\n", + "# 生成一个不平衡分类数据集\n", + "X, y = make_classification(n_classes=2, class_sep=2,\n", + " weights=[0.1, 0.9], n_informative=3,\n", + " n_redundant=1, flip_y=0, n_features=20,\n", + " n_clusters_per_class=1, n_samples=1000,\n", + " random_state=10)\n", + "\n", + "# 对样本进行过采样\n", + "smote = SMOTE(random_state=42)\n", + "X_resampled, y_resampled = smote.fit_resample(X, y)\n", + "\n", + "# 查看过采样后的样本数目\n", + "print(f\"原始样本数：{len(X)}\")\n", + "print(f\"过采样后样本数：{len(X_resampled)}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/AI/\347\245\236\347\273\217\347\275\221\347\273\234-\346\211\213\345\206\231\346\225\260\345\255\227.ipynb" "b/python/old-note-py-pyData/AI/\347\245\236\347\273\217\347\275\221\347\273\234-\346\211\213\345\206\231\346\225\260\345\255\227.ipynb" new file mode 100644 index 0000000..8aa628e --- /dev/null +++ "b/python/old-note-py-pyData/AI/\347\245\236\347\273\217\347\275\221\347\273\234-\346\211\213\345\206\231\346\225\260\345\255\227.ipynb" @@ -0,0 +1,165 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# 定义模型\n", + "model = keras.Sequential([\n", + " layers.Dense(64, activation='relu', input_shape=(784,)),\n", + " layers.Dense(64, activation='relu'),\n", + " layers.Dense(10, activation='softmax')\n", + "])\n", + "\n", + "# 编译模型\n", + "model.compile(optimizer=tf.optimizers.Adam(),\n", + " loss=tf.losses.SparseCategoricalCrossentropy(),\n", + " metrics=['accuracy'])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/5\n", + "1500/1500 [==============================] - 3s 2ms/step - loss: 0.3145 - accuracy: 0.9077 - val_loss: 0.1627 - val_accuracy: 0.9530\n", + "Epoch 2/5\n", + "1500/1500 [==============================] - 2s 2ms/step - loss: 0.1389 - accuracy: 0.9589 - val_loss: 0.1303 - val_accuracy: 0.9609\n", + "Epoch 3/5\n", + "1500/1500 [==============================] - 3s 2ms/step - loss: 0.1000 - accuracy: 0.9696 - val_loss: 0.1021 - val_accuracy: 0.9701\n", + "Epoch 4/5\n", + "1500/1500 [==============================] - 2s 2ms/step - loss: 0.0784 - accuracy: 0.9760 - val_loss: 0.1004 - val_accuracy: 0.9703\n", + "Epoch 5/5\n", + "1500/1500 [==============================] - 2s 2ms/step - loss: 0.0624 - accuracy: 0.9814 - val_loss: 0.1030 - val_accuracy: 0.9685\n" + ] + } + ], + "source": [ + "# 加载数据集\n", + "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n", + "\n", + "# 数据归一化\n", + "x_train = x_train.reshape(60000, 784).astype('float32') / 255.0\n", + "x_test = x_test.reshape(10000, 784).astype('float32') / 255.0\n", + "\n", + "# 训练模型，并记录指标\n", + "history = model.fit(x_train, y_train, epochs=5, batch_size=32, validation_split=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "313/313 [==============================] - 0s 1ms/step - loss: 0.0959 - accuracy: 0.9709\n", + "Test accuracy: 0.9708999991416931\n" + ] + } + ], + "source": [ + "# 评估模型\n", + "test_loss, test_acc = model.evaluate(x_test, y_test)\n", + "print('Test accuracy:', test_acc)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制训练集和验证集的损失\n", + "plt.plot(history.history['loss'], label='train loss')\n", + "plt.plot(history.history['val_loss'], label='val loss')\n", + "plt.title('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# 绘制训练集和验证集的准确度\n", + "plt.plot(history.history['accuracy'], label='train accuracy')\n", + "plt.plot(history.history['val_accuracy'], label='val accuracy')\n", + "plt.title('Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/01-\347\233\264\346\226\271\345\233\276.ipynb" "b/python/old-note-py-pyData/Example/01-\347\233\264\346\226\271\345\233\276.ipynb" new file mode 100644 index 0000000..c7be978 --- /dev/null +++ "b/python/old-note-py-pyData/Example/01-\347\233\264\346\226\271\345\233\276.ipynb" @@ -0,0 +1,147 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 简单使用" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "直方图(Histogram), 一般用于描述连续型数据的分布情况。 它将数据划分成若干个等距的区间，并用每个区间的高度来表示该区间内的数据数量或频率。\n", + "\n", + "而 bar 一般用于描述离散型数据的大小或数量。 它将每个数据按照类别进行分组。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGfCAYAAAB1KinVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh7ElEQVR4nO3de3BU9d3H8U8SyHLdjQGSJUMCiApELjJcwiq1ICkhIEoFWyyFaBkoTMKIsQpxENSnbSg6hUIR7LQF7ZCCtgUKKBgDhDqGqzLcJBUGJsGwAWGyC+mwgeQ8fzzDzrMVhA1Zzi/h/Zo5M9lzzp79ngHM27O3KMuyLAEAABgk2u4BAAAA/huBAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIzTLJydly9fruXLl+vUqVOSpAcffFDz5s1TZmamJOny5ct68cUXtWbNGgUCAWVkZOjtt99WYmJi8BhlZWWaMWOGtm/frjZt2igrK0v5+flq1uzWR6mrq1NFRYXatm2rqKiocE4BAADYxLIsXbx4UUlJSYqOvsk1EisM//znP63Nmzdb//73v63S0lLrlVdesZo3b24dPnzYsizLmj59upWcnGwVFRVZ+/btswYPHmw9/PDDwftfvXrV6tWrl5Wenm598cUX1ocffmi1b9/eysvLC2cMq7y83JLEwsLCwsLC0giX8vLym/6uj7Ks2/uywPj4eL355psaP368OnTooIKCAo0fP16SdOzYMfXs2VMlJSUaPHiwPvroIz3++OOqqKgIXlVZsWKFZs+erXPnzik2NvaWHtPn8ykuLk7l5eVyOp23Mz4AALhD/H6/kpOTVVVVJZfL9Z37hvUUz/9XW1urDz74QNXV1fJ4PNq/f7+uXLmi9PT04D49evRQSkpKMFBKSkrUu3fvkKd8MjIyNGPGDB05ckT9+vW77mMFAgEFAoHg7YsXL0qSnE4ngQIAQCNzKy/PCPtFsocOHVKbNm3kcDg0ffp0rVu3TqmpqfJ6vYqNjVVcXFzI/omJifJ6vZIkr9cbEifXtl/bdiP5+flyuVzBJTk5OdyxAQBAIxJ2oHTv3l0HDhzQ7t27NWPGDGVlZeno0aORmC0oLy9PPp8vuJSXl0f08QAAgL3CfoonNjZW9913nySpf//+2rt3r373u9/pxz/+sWpqalRVVRVyFaWyslJut1uS5Ha7tWfPnpDjVVZWBrfdiMPhkMPhCHdUAADQSN3256DU1dUpEAiof//+at68uYqKioLbSktLVVZWJo/HI0nyeDw6dOiQzp49G9ynsLBQTqdTqamptzsKAABoIsK6gpKXl6fMzEylpKTo4sWLKigo0I4dO7R161a5XC5NmTJFubm5io+Pl9Pp1MyZM+XxeDR48GBJ0ogRI5SamqpJkyZp4cKF8nq9mjt3rrKzs7lCAgAAgsIKlLNnz2ry5Mk6c+aMXC6X+vTpo61bt+oHP/iBJGnRokWKjo7WuHHjQj6o7ZqYmBht2rRJM2bMkMfjUevWrZWVlaU33nijYc8KAAA0arf9OSh28Pv9crlc8vl8vM0YAIBGIpzf33wXDwAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjhP1dPAAaly5zNts9QthOLRht9wgAbMYVFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgnGZ2DwAA/63LnM12jxC2UwtG2z0C0KSEdQUlPz9fAwcOVNu2bZWQkKCxY8eqtLQ0ZJ+hQ4cqKioqZJk+fXrIPmVlZRo9erRatWqlhIQEvfTSS7p69ertnw0AAGgSwrqCUlxcrOzsbA0cOFBXr17VK6+8ohEjRujo0aNq3bp1cL+pU6fqjTfeCN5u1apV8Ofa2lqNHj1abrdbn332mc6cOaPJkyerefPm+vWvf90ApwQAABq7sAJly5YtIbdXrVqlhIQE7d+/X48++mhwfatWreR2u697jI8//lhHjx7VJ598osTERD300EP6n//5H82ePVuvvfaaYmNj63EaAACgKbmtF8n6fD5JUnx8fMj61atXq3379urVq5fy8vL0n//8J7itpKREvXv3VmJiYnBdRkaG/H6/jhw5ct3HCQQC8vv9IQsAAGi66v0i2bq6Os2aNUuPPPKIevXqFVz/k5/8RJ07d1ZSUpIOHjyo2bNnq7S0VP/4xz8kSV6vNyROJAVve73e6z5Wfn6+Xn/99fqOCgAAGpl6B0p2drYOHz6sTz/9NGT9tGnTgj/37t1bHTt21PDhw3XixAl169atXo+Vl5en3Nzc4G2/36/k5OT6DQ4AAIxXr6d4cnJytGnTJm3fvl2dOnX6zn3T0tIkScePH5ckud1uVVZWhuxz7faNXrficDjkdDpDFgAA0HSFFSiWZSknJ0fr1q3Ttm3b1LVr15ve58CBA5Kkjh07SpI8Ho8OHTqks2fPBvcpLCyU0+lUampqOOMAAIAmKqyneLKzs1VQUKANGzaobdu2wdeMuFwutWzZUidOnFBBQYFGjRqldu3a6eDBg3rhhRf06KOPqk+fPpKkESNGKDU1VZMmTdLChQvl9Xo1d+5cZWdny+FwNPwZAgCARiesKyjLly+Xz+fT0KFD1bFjx+Cydu1aSVJsbKw++eQTjRgxQj169NCLL76ocePGaePGjcFjxMTEaNOmTYqJiZHH49FPf/pTTZ48OeRzUwAAwN0trCsolmV95/bk5GQVFxff9DidO3fWhx9+GM5DAwCAuwhfFggAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOOEFSj5+fkaOHCg2rZtq4SEBI0dO1alpaUh+1y+fFnZ2dlq166d2rRpo3HjxqmysjJkn7KyMo0ePVqtWrVSQkKCXnrpJV29evX2zwYAADQJYQVKcXGxsrOztWvXLhUWFurKlSsaMWKEqqurg/u88MIL2rhxoz744AMVFxeroqJCTz31VHB7bW2tRo8erZqaGn322Wd69913tWrVKs2bN6/hzgoAADRqUZZlWfW987lz55SQkKDi4mI9+uij8vl86tChgwoKCjR+/HhJ0rFjx9SzZ0+VlJRo8ODB+uijj/T444+roqJCiYmJkqQVK1Zo9uzZOnfunGJjY2/6uH6/Xy6XSz6fT06ns77jA3eFLnM22z3CXeHUgtF2jwAYL5zf37f1GhSfzydJio+PlyTt379fV65cUXp6enCfHj16KCUlRSUlJZKkkpIS9e7dOxgnkpSRkSG/368jR45c93ECgYD8fn/IAgAAmq56B0pdXZ1mzZqlRx55RL169ZIkeb1excbGKi4uLmTfxMREeb3e4D7/P06ubb+27Xry8/PlcrmCS3Jycn3HBgAAjUC9AyU7O1uHDx/WmjVrGnKe68rLy5PP5wsu5eXlEX9MAABgn2b1uVNOTo42bdqknTt3qlOnTsH1brdbNTU1qqqqCrmKUllZKbfbHdxnz549Ice79i6fa/v8N4fDIYfDUZ9RAQBAIxTWFRTLspSTk6N169Zp27Zt6tq1a8j2/v37q3nz5ioqKgquKy0tVVlZmTwejyTJ4/Ho0KFDOnv2bHCfwsJCOZ1Opaam3s65AACAJiKsKyjZ2dkqKCjQhg0b1LZt2+BrRlwul1q2bCmXy6UpU6YoNzdX8fHxcjqdmjlzpjwejwYPHixJGjFihFJTUzVp0iQtXLhQXq9Xc+fOVXZ2NldJAACApDADZfny5ZKkoUOHhqxfuXKlnn32WUnSokWLFB0drXHjxikQCCgjI0Nvv/12cN+YmBht2rRJM2bMkMfjUevWrZWVlaU33njj9s4EAAA0Gbf1OSh24XNQgFvH56DcGXwOCnBzd+xzUAAAACKBQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcZrZPQDQmHSZs9nuEQDgrsAVFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYJ+xA2blzp8aMGaOkpCRFRUVp/fr1IdufffZZRUVFhSwjR44M2efChQuaOHGinE6n4uLiNGXKFF26dOm2TgQAADQdYQdKdXW1+vbtq2XLlt1wn5EjR+rMmTPB5a9//WvI9okTJ+rIkSMqLCzUpk2btHPnTk2bNi386QEAQJPULNw7ZGZmKjMz8zv3cTgccrvd19325ZdfasuWLdq7d68GDBggSVq6dKlGjRqlt956S0lJSeGOBAAAmpiIvAZlx44dSkhIUPfu3TVjxgydP38+uK2kpERxcXHBOJGk9PR0RUdHa/fu3dc9XiAQkN/vD1kAAEDT1eCBMnLkSL333nsqKirSb37zGxUXFyszM1O1tbWSJK/Xq4SEhJD7NGvWTPHx8fJ6vdc9Zn5+vlwuV3BJTk5u6LEBAIBBwn6K52YmTJgQ/Ll3797q06ePunXrph07dmj48OH1OmZeXp5yc3ODt/1+P5ECwChd5my2e4SwnVow2u4RgBuK+NuM7733XrVv317Hjx+XJLndbp09ezZkn6tXr+rChQs3fN2Kw+GQ0+kMWQAAQNMV8UA5ffq0zp8/r44dO0qSPB6PqqqqtH///uA+27ZtU11dndLS0iI9DgAAaATCforn0qVLwashknTy5EkdOHBA8fHxio+P1+uvv65x48bJ7XbrxIkTevnll3XfffcpIyNDktSzZ0+NHDlSU6dO1YoVK3TlyhXl5ORowoQJvIMHAABIqscVlH379qlfv37q16+fJCk3N1f9+vXTvHnzFBMTo4MHD+qJJ57QAw88oClTpqh///7617/+JYfDETzG6tWr1aNHDw0fPlyjRo3SkCFD9Ic//KHhzgoAADRqYV9BGTp0qCzLuuH2rVu33vQY8fHxKigoCPehAQDAXYLv4gEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHHCDpSdO3dqzJgxSkpKUlRUlNavXx+y3bIszZs3Tx07dlTLli2Vnp6ur776KmSfCxcuaOLEiXI6nYqLi9OUKVN06dKl2zoRAADQdIQdKNXV1erbt6+WLVt23e0LFy7UkiVLtGLFCu3evVutW7dWRkaGLl++HNxn4sSJOnLkiAoLC7Vp0ybt3LlT06ZNq/9ZAACAJqVZuHfIzMxUZmbmdbdZlqXFixdr7ty5evLJJyVJ7733nhITE7V+/XpNmDBBX375pbZs2aK9e/dqwIABkqSlS5dq1KhReuutt5SUlHQbpwMAAJqCBn0NysmTJ+X1epWenh5c53K5lJaWppKSEklSSUmJ4uLignEiSenp6YqOjtbu3buve9xAICC/3x+yAACApqtBA8Xr9UqSEhMTQ9YnJiYGt3m9XiUkJIRsb9asmeLj44P7/Lf8/Hy5XK7gkpyc3JBjAwAAwzSKd/Hk5eXJ5/MFl/LycrtHAgAAEdSggeJ2uyVJlZWVIesrKyuD29xut86ePRuy/erVq7pw4UJwn//mcDjkdDpDFgAA0HQ1aKB07dpVbrdbRUVFwXV+v1+7d++Wx+ORJHk8HlVVVWn//v3BfbZt26a6ujqlpaU15DgAAKCRCvtdPJcuXdLx48eDt0+ePKkDBw4oPj5eKSkpmjVrln75y1/q/vvvV9euXfXqq68qKSlJY8eOlST17NlTI0eO1NSpU7VixQpduXJFOTk5mjBhAu/gAQAAkuoRKPv27dOwYcOCt3NzcyVJWVlZWrVqlV5++WVVV1dr2rRpqqqq0pAhQ7Rlyxa1aNEieJ/Vq1crJydHw4cPV3R0tMaNG6clS5Y0wOkAAICmIMqyLMvuIcLl9/vlcrnk8/l4PQruqC5zNts9AtBgTi0YbfcIuMuE8/u7UbyLBwAA3F0IFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxiFQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHGa2T0AAMAeXeZstnuEsJ1aMNruEXCHcAUFAAAYp8GvoLz22mt6/fXXQ9Z1795dx44dkyRdvnxZL774otasWaNAIKCMjAy9/fbbSkxMbOhRYLjG+H9vAIA7IyJXUB588EGdOXMmuHz66afBbS+88II2btyoDz74QMXFxaqoqNBTTz0ViTEAAEAjFZHXoDRr1kxut/tb630+n/70pz+poKBAjz32mCRp5cqV6tmzp3bt2qXBgwdf93iBQECBQCB42+/3R2JsAABgiIhcQfnqq6+UlJSke++9VxMnTlRZWZkkaf/+/bpy5YrS09OD+/bo0UMpKSkqKSm54fHy8/PlcrmCS3JyciTGBgAAhmjwQElLS9OqVau0ZcsWLV++XCdPntT3vvc9Xbx4UV6vV7GxsYqLiwu5T2Jiorxe7w2PmZeXJ5/PF1zKy8sbemwAAGCQBn+KJzMzM/hznz59lJaWps6dO+v9999Xy5Yt63VMh8Mhh8PRUCMCAADDRfxtxnFxcXrggQd0/Phxud1u1dTUqKqqKmSfysrK675mBQAA3J0iHiiXLl3SiRMn1LFjR/Xv31/NmzdXUVFRcHtpaanKysrk8XgiPQoAAGgkGvwpnl/84hcaM2aMOnfurIqKCs2fP18xMTF65pln5HK5NGXKFOXm5io+Pl5Op1MzZ86Ux+O54Tt4AADA3afBA+X06dN65plndP78eXXo0EFDhgzRrl271KFDB0nSokWLFB0drXHjxoV8UBsAAMA1UZZlWXYPES6/3y+XyyWfzyen02n3OKgnPkkWQLj4Lp7GLZzf33wXDwAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4xAoAADAOAQKAAAwDoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIzTzO4BAAC4VV3mbLZ7hLCdWjDa7hEaJa6gAAAA4xAoAADAODzF00Q0xsueAADcCFdQAACAcQgUAABgHAIFAAAYh0ABAADGIVAAAIBxCBQAAGAcAgUAABiHQAEAAMYhUAAAgHEIFAAAYBwCBQAAGIdAAQAAxrE1UJYtW6YuXbqoRYsWSktL0549e+wcBwAAGMK2bzNeu3atcnNztWLFCqWlpWnx4sXKyMhQaWmpEhIS7BpLEt8MDABoOI31d8qpBaNtfXzbAuW3v/2tpk6dqueee06StGLFCm3evFl//vOfNWfOnJB9A4GAAoFA8LbP55Mk+f3+iMxWF/hPRI4LAEBjEYnfsdeOaVnWzXe2bBAIBKyYmBhr3bp1IesnT55sPfHEE9/af/78+ZYkFhYWFhYWliawlJeX37QVbLmC8s0336i2tlaJiYkh6xMTE3Xs2LFv7Z+Xl6fc3Nzg7bq6Ol24cEHt2rVTVFRUcL3f71dycrLKy8vldDojdwKG4HybNs636bvbzpnzbdpu5Xwty9LFixeVlJR00+PZ9hRPOBwOhxwOR8i6uLi4G+7vdDrvir8M13C+TRvn2/TdbefM+TZtNztfl8t1S8ex5V087du3V0xMjCorK0PWV1ZWyu122zESAAAwiC2BEhsbq/79+6uoqCi4rq6uTkVFRfJ4PHaMBAAADGLbUzy5ubnKysrSgAEDNGjQIC1evFjV1dXBd/XUh8Ph0Pz587/1dFBTxfk2bZxv03e3nTPn27Q19PlGWdatvNcnMn7/+9/rzTfflNfr1UMPPaQlS5YoLS3NrnEAAIAhbA0UAACA6+G7eAAAgHEIFAAAYBwCBQAAGIdAAQAAxmnygRIIBPTQQw8pKipKBw4csHuciHniiSeUkpKiFi1aqGPHjpo0aZIqKirsHisiTp06pSlTpqhr165q2bKlunXrpvnz56umpsbu0SLqV7/6lR5++GG1atXqOz9JubFatmyZunTpohYtWigtLU179uyxe6SI2blzp8aMGaOkpCRFRUVp/fr1do8UMfn5+Ro4cKDatm2rhIQEjR07VqWlpXaPFVHLly9Xnz59gp+o6vF49NFHH9k91h2xYMECRUVFadasWbd9rCYfKC+//PItfeZ/Yzds2DC9//77Ki0t1d///nedOHFC48ePt3usiDh27Jjq6ur0zjvv6MiRI1q0aJFWrFihV155xe7RIqqmpkZPP/20ZsyYYfcoDW7t2rXKzc3V/Pnz9fnnn6tv377KyMjQ2bNn7R4tIqqrq9W3b18tW7bM7lEirri4WNnZ2dq1a5cKCwt15coVjRgxQtXV1XaPFjGdOnXSggULtH//fu3bt0+PPfaYnnzySR05csTu0SJq7969euedd9SnT5+GOWADfDmxsT788EOrR48e1pEjRyxJ1hdffGH3SHfMhg0brKioKKumpsbuUe6IhQsXWl27drV7jDti5cqVlsvlsnuMBjVo0CArOzs7eLu2ttZKSkqy8vPzbZzqzpD0rW92b8rOnj1rSbKKi4vtHuWOuueee6w//vGPdo8RMRcvXrTuv/9+q7Cw0Pr+979vPf/887d9zCZ7BaWyslJTp07VX/7yF7Vq1cruce6oCxcuaPXq1Xr44YfVvHlzu8e5I3w+n+Lj4+0eA/VQU1Oj/fv3Kz09PbguOjpa6enpKikpsXEyRILP55Oku+bfa21trdasWaPq6uom/VUu2dnZGj16dMi/49vVJAPFsiw9++yzmj59ugYMGGD3OHfM7Nmz1bp1a7Vr105lZWXasGGD3SPdEcePH9fSpUv185//3O5RUA/ffPONamtrlZiYGLI+MTFRXq/XpqkQCXV1dZo1a5YeeeQR9erVy+5xIurQoUNq06aNHA6Hpk+frnXr1ik1NdXusSJizZo1+vzzz5Wfn9+gx21UgTJnzhxFRUV953Ls2DEtXbpUFy9eVF5ent0j35ZbPd9rXnrpJX3xxRf6+OOPFRMTo8mTJ8tqRB8UHO75StLXX3+tkSNH6umnn9bUqVNtmrz+6nPOQGOVnZ2tw4cPa82aNXaPEnHdu3fXgQMHtHv3bs2YMUNZWVk6evSo3WM1uPLycj3//PNavXq1WrRo0aDHblQfdX/u3DmdP3/+O/e599579aMf/UgbN25UVFRUcH1tba1iYmI0ceJEvfvuu5EetUHc6vnGxsZ+a/3p06eVnJyszz77rNFcVgz3fCsqKjR06FANHjxYq1atUnR0o+ptSfX7M161apVmzZqlqqqqCE93Z9TU1KhVq1b629/+prFjxwbXZ2VlqaqqqslfCYyKitK6detCzr0pysnJ0YYNG7Rz50517drV7nHuuPT0dHXr1k3vvPOO3aM0qPXr1+uHP/yhYmJigutqa2sVFRWl6OhoBQKBkG3hsO3bjOujQ4cO6tChw033W7JkiX75y18Gb1dUVCgjI0Nr165tVF9GeKvnez11dXWS/u9t1o1FOOf79ddfa9iwYerfv79WrlzZKONEur0/46YiNjZW/fv3V1FRUfCXdF1dnYqKipSTk2PvcLhtlmVp5syZWrdunXbs2HFXxon0f3+nG9N/j2/V8OHDdejQoZB1zz33nHr06KHZs2fXO06kRhYotyolJSXkdps2bSRJ3bp1U6dOnewYKaJ2796tvXv3asiQIbrnnnt04sQJvfrqq+rWrVujuXoSjq+//lpDhw5V586d9dZbb+ncuXPBbW6328bJIqusrEwXLlxQWVmZamtrg5/rc9999wX/jjdWubm5ysrK0oABAzRo0CAtXrxY1dXVeu655+weLSIuXbqk48ePB2+fPHlSBw4cUHx8/Lf++9XYZWdnq6CgQBs2bFDbtm2DrytyuVxq2bKlzdNFRl5enjIzM5WSkqKLFy+qoKBAO3bs0NatW+0ercG1bdv2W68nuvZayNt+ndFtvw+oETh58mSTfpvxwYMHrWHDhlnx8fGWw+GwunTpYk2fPt06ffq03aNFxMqVKy1J112asqysrOue8/bt2+0erUEsXbrUSklJsWJjY61BgwZZu3btsnukiNm+fft1/yyzsrLsHq3B3ejf6sqVK+0eLWJ+9rOfWZ07d7ZiY2OtDh06WMOHD7c+/vhju8e6YxrqbcaN6jUoAADg7tA4n7gHAABNGoECAACMQ6AAAADjECgAAMA4BAoAADAOgQIAAIxDoAAAAOMQKAAAwDgECgAAMA6BAgAAjEOgAAAA4/wvLwVcCHHvWsQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 生成一些随机数据\n", + "data = np.random.randn(1000)\n", + "\n", + "# 绘制直方图\n", + "plt.hist(data)\n", + "\n", + "# 显示图形\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 生成一些随机数据\n", + "data = np.random.randn(1000)\n", + "\n", + "# 绘制直方图\n", + "plt.hist(data, bins=50, histtype='bar', linewidth=1, edgecolor='black')\n", + "\n", + "plt.ylim(0,70)\n", + "plt.xlim(-5,5)\n", + "\n", + "# 显示图形\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 相关参数" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "语法:\n", + "```py\n", + "matplotlib.pyplot.hist(x, bins=None, range=None, density=None, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, *, data=None, **kwargs)\n", + "```\n", + "- `x`: (array_like) 要绘制直方图的数据\n", + "- `bins`: (int, str, sequence, optional) 直方图条形数目。可以是一个整数，表示bins数量，也可以是一个序列，定义每个bin的边界值。默认值为10。\n", + "- `range`: (tuple, optional) 数据显示范围，将会把所有数据限制在这个范围内。默认使用data的范围。\n", + "- `density`: (bool, optional) 是否显示概率密度而不是计数，默认值为False。\n", + "- `weights`: (array_like, optional) 与x长度相同的数组。这些数组用于加权x中的值。默认情况下，每个值都具有相同的重量。\n", + "- `cumulative`: (bool, optional) 是否要对每个元素的累加进行直方图处理。如果设置为True，则返回累积直方图，默认为False。\n", + "- `bottom`: (scalar, optional) 直方图的y坐标轴最低点位置。默认值为None，即从0开始。\n", + "- `histtype`: ('bar', 'barstacked', 'step', 'stepfilled') 直方图类型。根据需要选择，例如：'bar'，'barstacked'，'step'，'stepfilled'。默认是'bar'。\n", + "- `align`: ('left', 'mid', 'right'), optional) 条形边缘的位置。默认是'left'。\n", + "- `orientation`: ('horizontal', 'vertical') 直方图定向，默认为'vertical'。\n", + "- `rwidth`: (scalar, optional) 直方图条形宽度，相对于bin宽度的比例。如果不提供，则自动计算。无法与多项式或步幅虚线histtypes一起使用。 如果cumulative=True，则忽略此选项并保持基本宽度为1。\n", + "- `log`: (bool, optional) 是否对y轴进行对数缩放。默认为False。\n", + "- `color`: (color, optional) 直方图颜色。\n", + "- `label`: (str, optional) 图例标签。\n", + "- `stacked`: (bool, optional) 是否堆叠直方图。默认为False。\n", + "- `normed`: (deprecated, use density instead!)，与density参数等效。\n", + "- `data`: (array or DataFrame or list-like) 作为输入数据的对象。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/02-\346\237\261\347\212\266\345\233\276.ipynb" "b/python/old-note-py-pyData/Example/02-\346\237\261\347\212\266\345\233\276.ipynb" new file mode 100644 index 0000000..e074c26 --- /dev/null +++ "b/python/old-note-py-pyData/Example/02-\346\237\261\347\212\266\345\233\276.ipynb" @@ -0,0 +1,184 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 简单使用" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "和条形图类似, 但柱状图一般是竖着放的。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 数据\n", + "labels = ['A', 'B', 'C', 'D', 'E']\n", + "values = [10, 23, 45, 32, 18]\n", + "\n", + "# 绘制垂直条形图\n", + "plt.bar(labels, values)\n", + "\n", + "# 添加标题和标签\n", + "plt.title('Bar Chart Horizontal')\n", + "plt.xlabel('Category')\n", + "plt.ylabel('Value')\n", + "\n", + "# 显示图表\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 数据\n", + "data = [(0, 0.174), (1, 0.088), (2, 0.086), (3, 0.08),\n", + " (4, 0.068), (5, 0.058), (6, 0.062), (7, 0.384)]\n", + "\n", + "# 将数据分为横坐标和纵坐标\n", + "x = [d[0] for d in data]\n", + "y = [d[1] for d in data]\n", + "\n", + "# 创建一个新的图像，并指定宽度为 6 英寸, 高度为 4 英寸\n", + "plt.figure(figsize=(6, 4))\n", + "\n", + "# 绘制直方图\n", + "plt.bar(x, y, width=0.4) # 后面的参数是可选的\n", + "\n", + "# 在每个柱子上显示纵坐标的值，旋转角度为 90 度\n", + "for i in range(len(x)):\n", + " plt.text(x[i], y[i] + 0.02,\n", + " '{:.3f}'.format(y[i]), rotation=90, ha='center', fontsize=14)\n", + "\n", + "# 设置横纵坐标的刻度\n", + "plt.xticks(range(8))\n", + "plt.yticks([i/10 for i in range(6)])\n", + "\n", + "# 显示图形\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "说明:\n", + "```py\n", + "plt.text(x[i] + 0.25, y[i]/2, '{:.3f}'.format(y[i]), rotation=90, ha='center', fontsize=8)\n", + "```\n", + "- `x[i] + 0.25` 表示文本放置的横坐标位置。这里加上 0.25 的偏移量是为了让文本居中显示在柱子的上方。\n", + "- `y[i]/2` 表示文本放置的纵坐标位置。这里使用 y[i]/2 是为了将文本放置在柱子高度的一半处。\n", + "- `'{:.3f}'.format(y[i])` 表示要显示的文本内容，即纵坐标的值。{:.3f} 表示格式化字符串，表示保留小数点后三位。\n", + "- `rotation=90` 表示旋转角度，这里设置为 90 度，使文本垂直显示。\n", + "- `ha='center'` 表示水平对齐方式，这里设置为居中对齐，使文本水平居中显示。\n", + "- `fontsize=8` 表示字体大小，这里设置为 8 号字体。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 创建数据\n", + "data = {'Class': [0, 0, 1] }\n", + "df = pd.DataFrame(data)\n", + "\n", + "# 统计 Class 值中 0 和 1 出现的次数\n", + "counts = df['Class'].value_counts()\n", + "\n", + "# 绘制柱状图\n", + "ax = counts.plot(kind='bar', rot=45, xlabel='Class', ylabel='Count')\n", + "\n", + "# 在柱形上添加数值标签\n", + "for p in ax.containers:\n", + " ax.bar_label(p, label_type='edge')\n", + "\n", + "# 展示图形\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/03-\346\235\241\345\275\242\345\233\276.ipynb" "b/python/old-note-py-pyData/Example/03-\346\235\241\345\275\242\345\233\276.ipynb" new file mode 100644 index 0000000..6560068 --- /dev/null +++ "b/python/old-note-py-pyData/Example/03-\346\235\241\345\275\242\345\233\276.ipynb" @@ -0,0 +1,84 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 简单使用" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "条形图, 一般指的是横着放的图表, 竖着放的叫做柱形图。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 数据\n", + "labels = ['A', 'B', 'C', 'D', 'E']\n", + "values = [10, 23, 45, 32, 18]\n", + "\n", + "# 绘制条形图\n", + "plt.barh(labels, values)\n", + "\n", + "# 添加标题和标签\n", + "plt.title('Bar Chart Horizontal')\n", + "plt.xlabel('Category')\n", + "plt.ylabel('Value')\n", + "\n", + "# 显示图表\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/04 \346\225\243\347\202\271\345\235\220\346\240\207\345\233\276.ipynb" "b/python/old-note-py-pyData/Example/04 \346\225\243\347\202\271\345\235\220\346\240\207\345\233\276.ipynb" new file mode 100644 index 0000000..38f62af --- /dev/null +++ "b/python/old-note-py-pyData/Example/04 \346\225\243\347\202\271\345\235\220\346\240\207\345\233\276.ipynb" @@ -0,0 +1,457 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 最简单的示例" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 定义数据集\n", + "x = [1, 2, 3, 4, 5]\n", + "y = [2, 4, 5, 4, 3]\n", + "\n", + "# 绘制散点图\n", + "plt.scatter(x, y)\n", + "\n", + "# 设置图表标题和轴标签\n", + "plt.title(\"Scatter Plot Example\")\n", + "plt.xlabel(\"X-axis label\")\n", + "plt.ylabel(\"Y-axis label\")\n", + "\n", + "# 显示图表\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 排列组合各列, 并依次绘制其散点图" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABCD
020778740
1884398
24811137
31496413
44072649
\n", + "
" + ], + "text/plain": [ + " A B C D\n", + "0 20 77 87 40\n", + "1 88 4 39 8\n", + "2 4 81 11 37\n", + "3 14 9 64 13\n", + "4 40 7 26 49" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "data = pd.DataFrame({\n", + " 'A': [20, 88, 4, 14, 40],\n", + " 'B': [77, 4, 81, 9, 7],\n", + " 'C': [87, 39, 11, 64, 26],\n", + " 'D': [40, 8, 37, 13, 49]\n", + "})\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAGwCAYAAAC6ty9tAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAjZ0lEQVR4nO3de3BU5f3H8c8mIRcl2ZgI2UQSDHgJMcAICqxiWyEW0IkgoVUHFQacjjRSLrYKWo1MS0PrjFZmFFvrwFhulVbQ0BqkQcPQhlswQopG0ChRcnGK2Q1oAibP7w9+7LiQ1CQGzubJ+zWzM+Scw/p9XCd5e/bsicsYYwQAAGCBMKcHAAAA6C6EDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsEeH0AOdba2urjh49qtjYWLlcLqfHAQAAHWCMUWNjo1JSUhQW1vHzMNaHzdGjR5Wamur0GAAAoAuqq6s1YMCADh9vfdjExsZKOv0vJi4uzuFpAABAR/j9fqWmpgZ+jneU9WFz5u2nuLg4wgYAgB6ms5eRcPEwAACwBmEDAACs4WjYPPnkk3K5XEGPjIyMwP6mpibl5eUpMTFRffv2VW5ururq6hycGAAAhDLHz9hcc801qqmpCTx27NgR2LdgwQIVFhZqw4YNKikp0dGjRzV16lQHpwUAAKHM8YuHIyIi5PF4ztnu8/n00ksvae3atRo3bpwkaeXKlRoyZIh27typMWPGXOhRAQBAiHP8jM2hQ4eUkpKiQYMGafr06Tpy5IgkqaysTKdOnVJ2dnbg2IyMDKWlpam0tLTd52tubpbf7w96AACA3sHRsBk9erRWrVqloqIirVixQlVVVbrpppvU2Nio2tpaRUZGKj4+PujvJCUlqba2tt3nLCgokNvtDjy4OR8AAL2Ho29FTZo0KfDnYcOGafTo0Ro4cKBeeeUVxcTEdOk5Fy9erIULFwa+PnODHwAAYD/H34r6pvj4eF111VU6fPiwPB6PTp48qYaGhqBj6urq2rwm54yoqKjAzfi4KR8AAL1LSIXN8ePH9eGHHyo5OVkjR45Unz59VFxcHNhfWVmpI0eOyOv1OjglLoSWVqPSD/+r18o/U+mH/1VLq3F6JABAD+DoW1E///nPlZOTo4EDB+ro0aPKz89XeHi47r77brndbs2ePVsLFy5UQkKC4uLiNHfuXHm9Xj4RZbmiihotKTyoGl9TYFuyO1r5OZmamJXs4GQAgFDnaNh8+umnuvvuu/Xf//5X/fr109ixY7Vz507169dPkvTMM88oLCxMubm5am5u1oQJE/T88887OTLOs6KKGs1ZvU9nn5+p9TVpzup9WnHPCOIGANAulzHG6nP8fr9fbrdbPp+P621CXEur0djfbgs6U/NNLkked7R2PDJO4WGd+6VoAICepas/v0PqGhv0brurjrUbNZJkJNX4mrS76tiFGwoA0KMQNggZ9Y3tR01XjgMA9D6EDUJG/9jobj0OAND7EDYIGaPSE5TsjlZ7V8+4dPrTUaPSEy7kWACAHoSwQcgID3MpPydTks6JmzNf5+dkcuEwAKBdhA1CysSsZK24Z4Q87uC3mzzuaD7qDQD4Vo7exwZoy8SsZN2S6dHuqmOqb2xS/9jTbz9xpgYA8G0IG4Sk8DCXvIMTnR4DANDD8FYUAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsEeH0AAAAoOdpaTXaXXVM9Y1N6h8brVHpCQoPczk9VuicsVm2bJlcLpfmz58f2NbU1KS8vDwlJiaqb9++ys3NVV1dnXNDAgAAFVXUaOxvt+nuF3dq3vpy3f3iTo397TYVVdQ4PVpohM2ePXv0hz/8QcOGDQvavmDBAhUWFmrDhg0qKSnR0aNHNXXqVIemBAAARRU1mrN6n2p8TUHba31NmrN6n+Nx43jYHD9+XNOnT9eLL76oSy65JLDd5/PppZde0tNPP61x48Zp5MiRWrlypf79739r586dDk4MAEDv1NJqtKTwoEwb+85sW1J4UC2tbR1xYTgeNnl5ebrtttuUnZ0dtL2srEynTp0K2p6RkaG0tDSVlpa2+3zNzc3y+/1BDwAA8N3trjp2zpmabzKSanxN2l117MINdRZHLx5ev3699u3bpz179pyzr7a2VpGRkYqPjw/anpSUpNra2nafs6CgQEuWLOnuUQEA6PXqG9uPmq4cdz44dsamurpa8+bN05o1axQdHd1tz7t48WL5fL7Ao7q6utueGwCA3qx/bMd+Xnf0uPPBsbApKytTfX29RowYoYiICEVERKikpETLly9XRESEkpKSdPLkSTU0NAT9vbq6Onk8nnafNyoqSnFxcUEPAADw3Y1KT1CyO1rtfajbJSnZffqj305xLGzGjx+vAwcOqLy8PPC47rrrNH369MCf+/Tpo+Li4sDfqays1JEjR+T1ep0aGwCAXis8zKX8nExJOiduznydn5Pp6P1sHLvGJjY2VllZWUHbLr74YiUmJga2z549WwsXLlRCQoLi4uI0d+5ceb1ejRkzxomRAQDo9SZmJWvFPSO0pPBg0IXEHne08nMyNTEr2cHpQvzOw88884zCwsKUm5ur5uZmTZgwQc8//7zTYwEA0KtNzErWLZmekLzzsMsY49yHzS8Av98vt9stn8/H9TYAAPQQXf357fh9bAAAALoLYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAaIf3bvUNVS6sJyd9oCgBAb0fYdFJRRY2WFB5Uja8psC3ZHa38nExNzEp2cDIAAMBbUZ1QVFGjOav3BUWNJNX6mjRn9T4VVdQ4NBkAAJAImw5raTVaUnhQpo19Z7YtKTyolta2jgAAABcCYdNBu6uOnXOm5puMpBpfk3ZXHbtwQwEAgCCETQfVN7YfNV05DgAAdD/CpoP6x0Z363EAAKD7ETYdNCo9QcnuaLX3oW6XTn86alR6woUcCwAAfANh00HhYS7l52RK0jlxc+br/JxM7mcDAICDCJtOmJiVrBX3jJDHHfx2k8cdrRX3jOA+NgAAOIwb9HXSxKxk3ZLp4c7DAACEIMKmC8LDXPIOTnR6DAAAcBbeigIAANYgbAAAgDUIGwAAYA3CBgAAWIOwAQAA1iBsAACANQgbAABgDcIGAABYg7ABAADWIGwAAIA1CBsAAGANwgYAAFiDsAEAANYgbAAAgDUIGwAAYA3CBgAAWIOwAQAA1iBsAACANQgbAABgDcIGAABYg7ABAADWIGwAAIA1CBsAAGANwgYAAFiDsAEAANYgbAAAgDUIGwAAYA3CBgAAWIOwAQAA1iBsAACANQgbAABgDcIGAABYg7ABAADWIGwAAIA1CBsAAGANwgYAAFiDsAEAANYgbAAAgDUIGwAAYA3CBgAAWIOwAQAA1iBsAACANQgbAABgDcIGAABYg7ABAADWIGwAAIA1CBsAAGANR8NmxYoVGjZsmOLi4hQXFyev16s33ngjsL+pqUl5eXlKTExU3759lZubq7q6OgcnBgAAoczRsBkwYICWLVumsrIy7d27V+PGjdPkyZP1n//8R5K0YMECFRYWasOGDSopKdHRo0c1depUJ0cGAAAhzGWMMU4P8U0JCQl66qmnNG3aNPXr109r167VtGnTJEnvv/++hgwZotLSUo0ZM6ZDz+f3++V2u+Xz+RQXF3c+RwcAAN2kqz+/Q+Yam5aWFq1fv14nTpyQ1+tVWVmZTp06pezs7MAxGRkZSktLU2lpabvP09zcLL/fH/QAAAC9g+Nhc+DAAfXt21dRUVF64IEHtHHjRmVmZqq2tlaRkZGKj48POj4pKUm1tbXtPl9BQYHcbnfgkZqaep5XAAAAQoXjYXP11VervLxcu3bt0pw5czRjxgwdPHiwy8+3ePFi+Xy+wKO6urobpwUAAKEswukBIiMjdcUVV0iSRo4cqT179ujZZ5/VnXfeqZMnT6qhoSHorE1dXZ08Hk+7zxcVFaWoqKjzPTYAAAhBjp+xOVtra6uam5s1cuRI9enTR8XFxYF9lZWVOnLkiLxer4MTAgCAUOXoGZvFixdr0qRJSktLU2Njo9auXau3335bW7Zskdvt1uzZs7Vw4UIlJCQoLi5Oc+fOldfr7fAnogAAQO/iaNjU19frvvvuU01Njdxut4YNG6YtW7bolltukSQ988wzCgsLU25urpqbmzVhwgQ9//zzTo4MAABCWMjdx6a7cR8bAAB6nh5/HxsAAIDvirABAADWIGwAAIA1On3xcGtrq1atWqVXX31VH3/8sVwul9LT0zVt2jTde++9crlc52NOAACAb9WpMzbGGN1+++26//779dlnn2no0KG65ppr9Mknn2jmzJm64447ztecAAAA36pTZ2xWrVql7du3q7i4WDfffHPQvm3btmnKlCl6+eWXdd9993XrkAAAAB3RqTM269at06OPPnpO1EjSuHHjtGjRIq1Zs6bbhgMAAOiMToXN/v37NXHixHb3T5o0Se++++53HgoAAKArOhU2x44dU1JSUrv7k5KS9MUXX3znoQAAALqiU2HT0tKiiIj2L8sJDw/X119//Z2HAgAA6IpOXTxsjNHMmTMVFRXV5v7m5uZuGQoAAKArOhU2M2bM+NZj+EQUAABwSqfCZuXKledrDgAAgO+MX6kAAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAazgaNgUFBbr++usVGxur/v37a8qUKaqsrAw6pqmpSXl5eUpMTFTfvn2Vm5ururo6hyYGAAChzNGwKSkpUV5ennbu3KmtW7fq1KlT+uEPf6gTJ04EjlmwYIEKCwu1YcMGlZSU6OjRo5o6daqDUwMAgFDlMsYYp4c44/PPP1f//v1VUlKi733ve/L5fOrXr5/Wrl2radOmSZLef/99DRkyRKWlpRozZsy3Pqff75fb7ZbP51NcXNz5XgIAAOgGXf35HVLX2Ph8PklSQkKCJKmsrEynTp1SdnZ24JiMjAylpaWptLS0zedobm6W3+8PegAAgN4hZMKmtbVV8+fP14033qisrCxJUm1trSIjIxUfHx90bFJSkmpra9t8noKCArnd7sAjNTX1fI8OAABCRMiETV5enioqKrR+/frv9DyLFy+Wz+cLPKqrq7tpQgAAEOoinB5Akh588EFt3rxZ27dv14ABAwLbPR6PTp48qYaGhqCzNnV1dfJ4PG0+V1RUlKKios73yAAAIAQ5esbGGKMHH3xQGzdu1LZt25Senh60f+TIkerTp4+Ki4sD2yorK3XkyBF5vd4LPS4AAAhxjp6xycvL09q1a/Xaa68pNjY2cN2M2+1WTEyM3G63Zs+erYULFyohIUFxcXGaO3euvF5vhz4RBQAAehdHP+7tcrna3L5y5UrNnDlT0ukb9D300ENat26dmpubNWHCBD3//PPtvhV1Nj7uDQBAz9PVn98hdR+b84GwAQCg57HiPjYAAADfBWEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsEaE0wMAAEJTS6vR7qpjqm9sUv/YaI1KT1B4mMvpsYD/ibABAJyjqKJGSwoPqsbXFNiW7I5Wfk6mJmYlOzgZ8L/xVhQAIEhRRY3mrN4XFDWSVOtr0pzV+1RUUePQZMC3I2wAAAEtrUZLCg/KtLHvzLYlhQfV0trWEYDzCBsAQMDuqmPnnKn5JiOpxtek3VXHLtxQQCcQNgCAgPrG9qOmK8cBFxphAwAI6B8b3a3HARcaYQMACBiVnqBkd7Ta+1C3S6c/HTUqPeFCjgV0GGEDAAgID3MpPydTks6JmzNf5+dkcj8bhCzCBgAQZGJWslbcM0Ied/DbTR53tFbcM4L72CCkcYM+AMA5JmYl65ZMD3ceRo9D2AAA2hQe5pJ3cKLTYwCdwltRAADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwhqNhs337duXk5CglJUUul0ubNm0K2m+M0RNPPKHk5GTFxMQoOztbhw4dcmZYAAAQ8hwNmxMnTmj48OF67rnn2tz/u9/9TsuXL9cLL7ygXbt26eKLL9aECRPU1NR0gScFAAA9QYST//BJkyZp0qRJbe4zxuj3v/+9fvnLX2ry5MmSpJdffllJSUnatGmT7rrrrgs5KgAA6AFC9hqbqqoq1dbWKjs7O7DN7XZr9OjRKi0tbffvNTc3y+/3Bz0AAEDvELJhU1tbK0lKSkoK2p6UlBTY15aCggK53e7AIzU19bzOCQAAQkfIhk1XLV68WD6fL/Corq52eiQAAHCBhGzYeDweSVJdXV3Q9rq6usC+tkRFRSkuLi7oAQAAeoeQDZv09HR5PB4VFxcHtvn9fu3atUter9fByQAAQKhy9FNRx48f1+HDhwNfV1VVqby8XAkJCUpLS9P8+fP161//WldeeaXS09P1+OOPKyUlRVOmTHFuaAAAELIcDZu9e/fq5ptvDny9cOFCSdKMGTO0atUqPfzwwzpx4oR+8pOfqKGhQWPHjlVRUZGio6OdGhkAAIQwlzHGOD3E+eT3++V2u+Xz+bjeBgCAHqKrP79D9hobAACAziJsAACANQgbAABgDcIGAABYw9FPRQHoXi2tRrurjqm+sUn9Y6M1Kj1B4WEup8cCgAuGsAEsUVRRoyWFB1XjawpsS3ZHKz8nUxOzkh2cDAAuHN6KAixQVFGjOav3BUWNJNX6mjRn9T4VVdQ4NBkAXFiEDdDDtbQaLSk8qLZuSHVm25LCg2pptfqWVQAgibABerzdVcfOOVPzTUZSja9Ju6uOXbihAMAhhA3Qw9U3th81XTkOAHoywgbo4frHdux3p3X0OADoyQgboIcblZ6gZHe02vtQt0unPx01Kj3hQo4FAI4gbIAeLjzMpfycTEk6J27OfJ2fk8n9bAD0CoQNYIGJWclacc8IedzBbzd53NFacc8I7mMDoNfgBn2AJSZmJeuWTA93HgbQqxE2gEXCw1zyDk50egwAcAxvRQEAAGsQNgAAwBqEDQAAsAZhAwAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrWH/nYWOMJMnv9zs8CQAA6KgzP7fP/BzvKOvDprGxUZKUmprq8CQAAKCzGhsb5Xa7O3y8y3Q2hXqY1tZWHT16VLGxsXK5uvbLAP1+v1JTU1VdXa24uLhunjC0sFZ79ab1slY79aa1Sr1rvW2t1RijxsZGpaSkKCys41fOWH/GJiwsTAMGDOiW54qLi7P+P64zWKu9etN6WaudetNapd613rPX2pkzNWdw8TAAALAGYQMAAKxB2HRAVFSU8vPzFRUV5fQo5x1rtVdvWi9rtVNvWqvUu9bbnWu1/uJhAADQe3DGBgAAWIOwAQAA1iBsAACANQgbAABgDcLm/23fvl05OTlKSUmRy+XSpk2bgvYbY/TEE08oOTlZMTExys7O1qFDh5wZ9jsqKCjQ9ddfr9jYWPXv319TpkxRZWVl0DFNTU3Ky8tTYmKi+vbtq9zcXNXV1Tk0cdetWLFCw4YNC9z0yev16o033gjst2WdbVm2bJlcLpfmz58f2GbTep988km5XK6gR0ZGRmC/TWuVpM8++0z33HOPEhMTFRMTo6FDh2rv3r2B/TZ9j7r88svPeW1dLpfy8vIk2fXatrS06PHHH1d6erpiYmI0ePBg/epXvwr6/Ug2vbaNjY2aP3++Bg4cqJiYGN1www3as2dPYH+3rNXAGGPMP/7xD/PYY4+ZV1991UgyGzduDNq/bNky43a7zaZNm8y7775rbr/9dpOenm6++uorZwb+DiZMmGBWrlxpKioqTHl5ubn11ltNWlqaOX78eOCYBx54wKSmppri4mKzd+9eM2bMGHPDDTc4OHXXvP766+bvf/+7+eCDD0xlZaV59NFHTZ8+fUxFRYUxxp51nm337t3m8ssvN8OGDTPz5s0LbLdpvfn5+eaaa64xNTU1gcfnn38e2G/TWo8dO2YGDhxoZs6caXbt2mU++ugjs2XLFnP48OHAMTZ9j6qvrw96Xbdu3WokmbfeessYY9dru3TpUpOYmGg2b95sqqqqzIYNG0zfvn3Ns88+GzjGptf2xz/+scnMzDQlJSXm0KFDJj8/38TFxZlPP/3UGNM9ayVs2nB22LS2thqPx2OeeuqpwLaGhgYTFRVl1q1b58CE3au+vt5IMiUlJcaY02vr06eP2bBhQ+CY9957z0gypaWlTo3ZbS655BLzpz/9ydp1NjY2miuvvNJs3brVfP/73w+EjW3rzc/PN8OHD29zn21rfeSRR8zYsWPb3W/796h58+aZwYMHm9bWVute29tuu83MmjUraNvUqVPN9OnTjTF2vbZffvmlCQ8PN5s3bw7aPmLECPPYY49121p5K6oDqqqqVFtbq+zs7MA2t9ut0aNHq7S01MHJuofP55MkJSQkSJLKysp06tSpoPVmZGQoLS2tR6+3paVF69ev14kTJ+T1eq1dZ15enm677bagdUl2vq6HDh1SSkqKBg0apOnTp+vIkSOS7Fvr66+/ruuuu04/+tGP1L9/f1177bV68cUXA/tt/h518uRJrV69WrNmzZLL5bLutb3hhhtUXFysDz74QJL07rvvaseOHZo0aZIku17br7/+Wi0tLYqOjg7aHhMTox07dnTbWq3/JZjdoba2VpKUlJQUtD0pKSmwr6dqbW3V/PnzdeONNyorK0vS6fVGRkYqPj4+6Nieut4DBw7I6/WqqalJffv21caNG5WZmany8nKr1ilJ69ev1759+4Lesz7Dttd19OjRWrVqla6++mrV1NRoyZIluummm1RRUWHdWj/66COtWLFCCxcu1KOPPqo9e/boZz/7mSIjIzVjxgyrv0dt2rRJDQ0NmjlzpiT7/jtetGiR/H6/MjIyFB4erpaWFi1dulTTp0+XZNfPn9jYWHm9Xv3qV7/SkCFDlJSUpHXr1qm0tFRXXHFFt62VsOnl8vLyVFFRoR07djg9ynlz9dVXq7y8XD6fT3/96181Y8YMlZSUOD1Wt6uurta8efO0devWc/6PyEZn/o9WkoYNG6bRo0dr4MCBeuWVVxQTE+PgZN2vtbVV1113nX7zm99Ikq699lpVVFTohRde0IwZMxye7vx66aWXNGnSJKWkpDg9ynnxyiuvaM2aNVq7dq2uueYalZeXa/78+UpJSbHytf3zn/+sWbNm6bLLLlN4eLhGjBihu+++W2VlZd32z+CtqA7weDySdM5V93V1dYF9PdGDDz6ozZs366233tKAAQMC2z0ej06ePKmGhoag43vqeiMjI3XFFVdo5MiRKigo0PDhw/Xss89at86ysjLV19drxIgRioiIUEREhEpKSrR8+XJFREQoKSnJqvWeLT4+XldddZUOHz5s3WubnJyszMzMoG1DhgwJvPVm6/eoTz75RP/85z91//33B7bZ9tr+4he/0KJFi3TXXXdp6NChuvfee7VgwQIVFBRIsu+1HTx4sEpKSnT8+HFVV1dr9+7dOnXqlAYNGtRtayVsOiA9PV0ej0fFxcWBbX6/X7t27ZLX63Vwsq4xxujBBx/Uxo0btW3bNqWnpwftHzlypPr06RO03srKSh05cqRHrvdsra2tam5utm6d48eP14EDB1ReXh54XHfddZo+fXrgzzat92zHjx/Xhx9+qOTkZOte2xtvvPGcWzJ88MEHGjhwoCT7vkedsXLlSvXv31+33XZbYJttr+2XX36psLDgH8Xh4eFqbW2VZO9re/HFFys5OVlffPGFtmzZosmTJ3ffWrvraueerrGx0bzzzjvmnXfeMZLM008/bd555x3zySefGGNOfwQtPj7evPbaa2b//v1m8uTJPfbjdnPmzDFut9u8/fbbQR+p/PLLLwPHPPDAAyYtLc1s27bN7N2713i9XuP1eh2cumsWLVpkSkpKTFVVldm/f79ZtGiRcblc5s033zTG2LPO9nzzU1HG2LXehx56yLz99tumqqrK/Otf/zLZ2dnm0ksvNfX19cYYu9a6e/duExERYZYuXWoOHTpk1qxZYy666CKzevXqwDE2fY8yxpiWlhaTlpZmHnnkkXP22fTazpgxw1x22WWBj3u/+uqr5tJLLzUPP/xw4BibXtuioiLzxhtvmI8++si8+eabZvjw4Wb06NHm5MmTxpjuWSth8//eeustI+mcx4wZM4wxpz9y9/jjj5ukpCQTFRVlxo8fbyorK50duovaWqcks3LlysAxX331lfnpT39qLrnkEnPRRReZO+64w9TU1Dg3dBfNmjXLDBw40ERGRpp+/fqZ8ePHB6LGGHvW2Z6zw8am9d55550mOTnZREZGmssuu8zceeedQfd1sWmtxhhTWFhosrKyTFRUlMnIyDB//OMfg/bb9D3KGGO2bNliJLW5BpteW7/fb+bNm2fS0tJMdHS0GTRokHnsscdMc3Nz4BibXtu//OUvZtCgQSYyMtJ4PB6Tl5dnGhoaAvu7Y60uY75xe0MAAIAejGtsAACANQgbAABgDcIGAABYg7ABAADWIGwAAIA1CBsAAGANwgYAAFiDsAEAANYgbAAAgDUIGwA9Um1trebOnatBgwYpKipKqampysnJCfoFegB6nwinBwCAzvr444914403Kj4+Xk899ZSGDh2qU6dOacuWLcrLy9P777/v9IgAHMLvigLQ49x6663av3+/KisrdfHFFwfta2hoUHx8vDODAXAcb0UB6FGOHTumoqIi5eXlnRM1kogaoJcjbAD0KIcPH5YxRhkZGU6PAiAEETYAehTePQfwvxA2AHqUK6+8Ui6XiwuEAbSJi4cB9DiTJk3SgQMHuHgYwDk4YwOgx3nuuefU0tKiUaNG6W9/+5sOHTqk9957T8uXL5fX63V6PAAO4owNgB6ppqZGS5cu1ebNm1VTU6N+/fpp5MiRWrBggX7wgx84PR4AhxA2AADAGrwVBQAArEHYAAAAaxA2AADAGoQNAACwBmEDAACsQdgAAABrEDYAAMAahA0AALAGYQMAAKxB2AAAAGsQNgAAwBr/BzFEDqLchvglAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取 A、B、C、D 列的数据\n", + "a = data['A']\n", + "b = data['B']\n", + "c = data['C']\n", + "d = data['D']\n", + "\n", + "# 创建散点图\n", + "for i in range(4):\n", + " for j in range(i+1, 4):\n", + " fig = plt.figure()\n", + " ax = fig.add_subplot(111)\n", + " ax.scatter(data.iloc[:, i], data.iloc[:, j])\n", + " ax.set_xlabel(data.columns[i])\n", + " ax.set_ylabel(data.columns[j])\n", + " plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 排列组合各列, 并依次绘制其散点图(更灵活)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def scatter_matrix(dataframe):\n", + " # 确定数据集中列的数量\n", + " num_cols = len(dataframe.columns)\n", + " \n", + " # 创建散点图矩阵\n", + " for i in range(num_cols):\n", + " for j in range(i+1, num_cols):\n", + " fig = plt.figure()\n", + " ax = fig.add_subplot(111)\n", + " ax.scatter(dataframe.iloc[:, i], dataframe.iloc[:, j])\n", + " ax.set_xlabel(dataframe.columns[i])\n", + " ax.set_ylabel(dataframe.columns[j])\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGyCAYAAAD+lC4cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAApHUlEQVR4nO3df3TU1Z3/8dfk1ySFZEJSMpNggtGyhojsCgiMsNuzGhsoZaVEt3hgFystlQZLQKVkdwPLKobSrVosP1YPBSsiK+dUbNxtODa0aVlDAmGhpikBarZJJTN0i5kJaAJmPt8/XObrSKIBQz5zk+fjnHsOc++dz7xzrsd5nc+POw7LsiwBAAAYKMbuAgAAAK4WQQYAABiLIAMAAIxFkAEAAMYiyAAAAGMRZAAAgLEIMgAAwFgEGQAAYCyCDAAAMFac3QVca6FQSKdPn1ZycrIcDofd5QAAgD6wLEsdHR3KyspSTMzHnHexbBQMBq1ly5ZZOTk5VmJiouX1eq26urrweCgUssrKyiyPx2MlJiZad955p3XixIkr+ozW1lZLEo1Go9FoNANba2vrx37P23pG5mtf+5oaGhr0wgsvKCsrSzt37lRBQYEaGxs1atQobdiwQRs3btTzzz+v3NxclZWVqbCwUI2NjUpMTOzTZyQnJ0uSWltblZKSci3/HAAA0E+CwaCys7PD3+O9cViWPT8a+d577yk5OVmvvvqqZs2aFe6fOHGiZs6cqccee0xZWVl6+OGH9cgjj0iSAoGA3G63duzYoXnz5vXpc4LBoFwulwKBAEEGAABD9PX727abfd9//311d3dfdmYlKSlJBw4cUHNzs3w+nwoKCsJjLpdLU6ZMUU1NTa/H7erqUjAYjGgAAGBwsi3IJCcny+v16rHHHtPp06fV3d2tnTt3qqamRm1tbfL5fJIkt9sd8T632x0e60l5eblcLle4ZWdnX9O/AwAA2MfWx69feOEFWZalUaNGyel0auPGjbrvvvs+/u7kT1BaWqpAIBBura2t/VgxAACIJrYGmRtvvFHV1dU6d+6cWltbVVdXp4sXL+qGG26Qx+ORJPn9/oj3+P3+8FhPnE6nUlJSIhoAABicomJDvGHDhikzM1PvvPOO9u3bp7vvvlu5ubnyeDyqqqoKzwsGg6qtrZXX67WxWgAAEC1sffx63759sixLN910k06dOqVHH31UeXl5+upXvyqHw6GSkhI9/vjjGjNmTPjx66ysLM2ZM8fOsgEAQJSwNcgEAgGVlpbqD3/4g9LS0lRUVKR169YpPj5ekrRy5UqdP39eixcvVnt7u6ZPn67Kyso+7yEDAAAGN9v2kRko7CMDAIB5on4fGQAAgE9r0P9oJMzRHbJU13xWZzo6lZGcqMm5aYqN4Yc+AQC9I8ggKlQ2tGltRaPaAp3hvkxXotbMzteMcZk2VgYAiGZcWoLtKhvatGTnkYgQI0m+QKeW7DyiyoY2myoDAEQ7ggxs1R2ytLaiUT3dcX6pb21Fo7pDg/qedADAVSLIwFZ1zWcvOxPzYZaktkCn6prPDlxRAABjEGRgqzMdvYeYq5kHABhaCDKwVUZy3zY37Os8AMDQQpCBrSbnpinTlajeHrJ26IOnlybnpg1kWQAAQxBkYKvYGIfWzM6XpMvCzKXXa2bns58MAKBHBBnYbsa4TG1ZMEEeV+TlI48rUVsWTGAfGQBAr9gQD1FhxrhM3ZXvYWdfAMAVIcggasTGOOS9Md3uMgAABuHSEgAAMBZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADAWQQYAABiLIAMAAIxFkAEAAMayNch0d3errKxMubm5SkpK0o033qjHHntMlmWF51iWpdWrVyszM1NJSUkqKCjQyZMnbawaAABEC1uDzHe+8x1t2bJFP/jBD/Tb3/5W3/nOd7RhwwY988wz4TkbNmzQxo0btXXrVtXW1mrYsGEqLCxUZ2enjZUDAIBo4LA+fPpjgH3pS1+S2+3Wtm3bwn1FRUVKSkrSzp07ZVmWsrKy9PDDD+uRRx6RJAUCAbndbu3YsUPz5s37xM8IBoNyuVwKBAJKSUm5Zn8LAADoP339/rb1jMztt9+uqqoqnThxQpJ07NgxHThwQDNnzpQkNTc3y+fzqaCgIPwel8ulKVOmqKampsdjdnV1KRgMRjQAADA4xdn54atWrVIwGFReXp5iY2PV3d2tdevWaf78+ZIkn88nSXK73RHvc7vd4bGPKi8v19q1a69t4QAAICrYekbm5Zdf1osvvqhdu3bpyJEjev755/Wv//qvev7556/6mKWlpQoEAuHW2trajxUDAIBoYusZmUcffVSrVq0K3+tyyy236Pe//73Ky8u1cOFCeTweSZLf71dmZmb4fX6/X3/xF3/R4zGdTqecTuc1rx0AANjP1jMy7777rmJiIkuIjY1VKBSSJOXm5srj8aiqqio8HgwGVVtbK6/XO6C1AgCA6GPrGZnZs2dr3bp1ysnJ0c0336z//u//1pNPPqkHHnhAkuRwOFRSUqLHH39cY8aMUW5ursrKypSVlaU5c+bYWToAAIgCtgaZZ555RmVlZfrmN7+pM2fOKCsrS9/4xje0evXq8JyVK1fq/PnzWrx4sdrb2zV9+nRVVlYqMTHRxsoBAEA0sHUfmYHAPjIAAJjHiH1kAAAAPg2CDAAAMBZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADAWQQYAABiLIAMAAIxFkAEAAMYiyAAAAGMRZAAAgLEIMgAAwFgEGQAAYCyCDAAAMBZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLFuDzPXXXy+Hw3FZKy4uliR1dnaquLhY6enpGj58uIqKiuT3++0sGQAARBFbg8yhQ4fU1tYWbq+//rok6d5775UkLV++XBUVFdqzZ4+qq6t1+vRpzZ07186SAQBAFHFYlmXZXcQlJSUleu2113Ty5EkFg0GNHDlSu3bt0j333CNJOn78uMaOHauamhpNnTq1T8cMBoNyuVwKBAJKSUm5luUDAIB+0tfv76i5R+bChQvauXOnHnjgATkcDtXX1+vixYsqKCgIz8nLy1NOTo5qamp6PU5XV5eCwWBEAwAAg1PUBJm9e/eqvb1d999/vyTJ5/MpISFBqampEfPcbrd8Pl+vxykvL5fL5Qq37Ozsa1g1AACwU9QEmW3btmnmzJnKysr6VMcpLS1VIBAIt9bW1n6qEAAARJs4uwuQpN///vf62c9+ph//+MfhPo/HowsXLqi9vT3irIzf75fH4+n1WE6nU06n81qWCwAAokRUnJHZvn27MjIyNGvWrHDfxIkTFR8fr6qqqnBfU1OTWlpa5PV67SgTAABEGdvPyIRCIW3fvl0LFy5UXNz/L8flcmnRokVasWKF0tLSlJKSooceekher7fPTywBAIDBzfYg87Of/UwtLS164IEHLht76qmnFBMTo6KiInV1damwsFCbN2+2oUoAABCNomofmWuBfWQAADCPcfvIAAAAXCmCDAAAMBZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICx4uwuANGjO2SprvmsznR0KiM5UZNz0xQb47C7LAAAekWQgSSpsqFNaysa1RboDPdluhK1Zna+ZozLtLEyAAB6x6UlqLKhTUt2HokIMZLkC3Rqyc4jqmxos6kyAAA+HkFmiOsOWVpb0Sirh7FLfWsrGtUd6mkGAAD2IsgMcXXNZy87E/NhlqS2QKfqms8OXFEAAPQRQWaIO9PRe4i5mnkAAAwkgswQl5Gc2K/zAAAYSASZIW5ybpoyXYnq7SFrhz54emlybtpAlgUAQJ8QZIa42BiH1szOl6TLwsyl12tm57OfDAAgKhFkoBnjMrVlwQR5XJGXjzyuRG1ZMIF9ZAAAUYsN8SDpgzBzV76HnX0BAEYhyCAsNsYh743pdpcBAECfcWkJAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAs24PM22+/rQULFig9PV1JSUm65ZZbdPjw4fC4ZVlavXq1MjMzlZSUpIKCAp08edLGigEAQLSwNci88847mjZtmuLj4/XTn/5UjY2N+t73vqcRI0aE52zYsEEbN27U1q1bVVtbq2HDhqmwsFCdnZ02Vg4AAKKBw7Isy64PX7Vqlf7rv/5Lv/rVr3octyxLWVlZevjhh/XII49IkgKBgNxut3bs2KF58+Zd9p6uri51dXWFXweDQWVnZysQCCglJeXa/CEAAKBfBYNBuVyuT/z+tvWMzE9+8hNNmjRJ9957rzIyMnTrrbfqueeeC483NzfL5/OpoKAg3OdyuTRlyhTV1NT0eMzy8nK5XK5wy87OvuZ/BwAAsIetQeatt97Sli1bNGbMGO3bt09LlizRt771LT3//POSJJ/PJ0lyu90R73O73eGxjyotLVUgEAi31tbWa/tHAAAA29j6o5GhUEiTJk3SE088IUm69dZb1dDQoK1bt2rhwoVXdUyn0ymn09mfZQIAgChl6xmZzMxM5efnR/SNHTtWLS0tkiSPxyNJ8vv9EXP8fn94DAAADF22Bplp06apqakpou/EiRMaPXq0JCk3N1cej0dVVVXh8WAwqNraWnm93gGtFQAARB9bLy0tX75ct99+u5544gn97d/+rerq6vTss8/q2WeflSQ5HA6VlJTo8ccf15gxY5Sbm6uysjJlZWVpzpw5dpYOAACigK1B5rbbbtMrr7yi0tJS/cu//Ityc3P19NNPa/78+eE5K1eu1Pnz57V48WK1t7dr+vTpqqysVGJioo2VAwCAaGDrPjIDoa/PoQMAgOhhxD4yAAAAnwZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADAWQQYAABiLIAMAAIxFkAEAAMYiyAAAAGMRZAAAgLEIMgAAwFgEGQAAYCyCDAAAMBZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwlq1B5p//+Z/lcDgiWl5eXni8s7NTxcXFSk9P1/Dhw1VUVCS/329jxQAAIJrYfkbm5ptvVltbW7gdOHAgPLZ8+XJVVFRoz549qq6u1unTpzV37lwbqwUAANEkzvYC4uLk8Xgu6w8EAtq2bZt27dqlO+64Q5K0fft2jR07VgcPHtTUqVMHulQAABBlbD8jc/LkSWVlZemGG27Q/Pnz1dLSIkmqr6/XxYsXVVBQEJ6bl5ennJwc1dTU9Hq8rq4uBYPBiAYAAAYnW4PMlClTtGPHDlVWVmrLli1qbm7WX/7lX6qjo0M+n08JCQlKTU2NeI/b7ZbP5+v1mOXl5XK5XOGWnZ19jf8KAABgF1svLc2cOTP87/Hjx2vKlCkaPXq0Xn75ZSUlJV3VMUtLS7VixYrw62AwSJgBAGCQuqIzMvv371d+fn6Pl2sCgYBuvvlm/epXv7rqYlJTU/Vnf/ZnOnXqlDwejy5cuKD29vaIOX6/v8d7ai5xOp1KSUmJaAAAYHC6oiDz9NNP6+tf/3qP4cDlcukb3/iGnnzyyasu5ty5c/rd736nzMxMTZw4UfHx8aqqqgqPNzU1qaWlRV6v96o/AwAADB5XFGSOHTumGTNm9Dr+hS98QfX19X0+3iOPPKLq6mr9z//8j9544w19+ctfVmxsrO677z65XC4tWrRIK1as0M9//nPV19frq1/9qrxeL08sAQAASVd4j4zf71d8fHzvB4uL0x//+Mc+H+8Pf/iD7rvvPv3pT3/SyJEjNX36dB08eFAjR46UJD311FOKiYlRUVGRurq6VFhYqM2bN19JyQAAYBC7oiAzatQoNTQ06HOf+1yP47/+9a+VmZnZ5+Pt3r37Y8cTExO1adMmbdq06UrKBAAAQ8QVXVr64he/qLKyMnV2dl429t5772nNmjX60pe+1G/FAQAAfByHZVlWXyf7/X5NmDBBsbGxWrp0qW666SZJ0vHjx7Vp0yZ1d3fryJEjcrvd16zgKxUMBuVyuRQIBHiCCQAAQ/T1+/uKLi253W698cYbWrJkiUpLS3UpAzkcDhUWFmrTpk1RFWIAAMDgdsUb4o0ePVr/+Z//qXfeeUenTp2SZVkaM2aMRowYcS3qAwAA6NVV7+w7YsQI3Xbbbf1ZCwAAwBWx/UcjAQAArhZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADAWQQYAABiLIAMAAIxFkAEAAMYiyAAAAGMRZAAAgLEIMgAAwFgEGQAAYCyCDAAAMBZBBgAAGIsgAwAAjEWQAQAAxoqaILN+/Xo5HA6VlJSE+zo7O1VcXKz09HQNHz5cRUVF8vv99hUJAACiSlQEmUOHDunf/u3fNH78+Ij+5cuXq6KiQnv27FF1dbVOnz6tuXPn2lQlAACINrYHmXPnzmn+/Pl67rnnNGLEiHB/IBDQtm3b9OSTT+qOO+7QxIkTtX37dr3xxhs6ePCgjRUDAIBoYXuQKS4u1qxZs1RQUBDRX19fr4sXL0b05+XlKScnRzU1Nb0er6urS8FgMKIBAID+1R2yVPO7P+nVo2+r5nd/UnfIsqWOOFs+9f/s3r1bR44c0aFDhy4b8/l8SkhIUGpqakS/2+2Wz+fr9Zjl5eVau3Ztf5cKAAD+T2VDm9ZWNKot0Bnuy3Qlas3sfM0Ylzmgtdh2Rqa1tVXLli3Tiy++qMTExH47bmlpqQKBQLi1trb227EBABjqKhvatGTnkYgQI0m+QKeW7Dyiyoa2Aa3HtiBTX1+vM2fOaMKECYqLi1NcXJyqq6u1ceNGxcXFye1268KFC2pvb494n9/vl8fj6fW4TqdTKSkpEQ0AAHx63SFLaysa1dNFpEt9aysaB/Qyk21B5s4779Sbb76po0ePhtukSZM0f/788L/j4+NVVVUVfk9TU5NaWlrk9XrtKhsAgCGrrvnsZWdiPsyS1BboVF3z2QGrybZ7ZJKTkzVu3LiIvmHDhik9PT3cv2jRIq1YsUJpaWlKSUnRQw89JK/Xq6lTp9pRMgAAQ9qZjt5DzNXM6w+23uz7SZ566inFxMSoqKhIXV1dKiws1ObNm+0uCwCAISkjuW/3tPZ1Xn9wWJZlz/NSAyQYDMrlcikQCHC/DAAAn0J3yNL07+yXL9DZ430yDkkeV6IOfPsOxcY4PtVn9fX72/Z9ZAAAgBliYxxaMztf0geh5cMuvV4zO/9Th5grQZABAAB9NmNcprYsmCCPK/LykceVqC0LJgz4PjJRfY8MAACIPjPGZequfI/qms/qTEenMpITNTk3bUDPxFxCkAEAAFcsNsYh743pdpfBpSUAAGAuggwAADAWQQYAABiLIAMAAIxFkAEAAMYiyAAAAGMRZAAAgLEIMgAAwFgEGQAAYCyCDAAAMBZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADAWQQYAABiLIAMAAIxFkAEAAMayNchs2bJF48ePV0pKilJSUuT1evXTn/40PN7Z2ani4mKlp6dr+PDhKioqkt/vt7FiAAAQTWwNMtddd53Wr1+v+vp6HT58WHfccYfuvvtu/eY3v5EkLV++XBUVFdqzZ4+qq6t1+vRpzZ07186SAQBAFHFYlmXZXcSHpaWl6bvf/a7uuecejRw5Urt27dI999wjSTp+/LjGjh2rmpoaTZ06tU/HCwaDcrlcCgQCSklJuZalAwCAftLX7++ouUemu7tbu3fv1vnz5+X1elVfX6+LFy+qoKAgPCcvL085OTmqqanp9ThdXV0KBoMRDQAADE62B5k333xTw4cPl9Pp1IMPPqhXXnlF+fn58vl8SkhIUGpqasR8t9stn8/X6/HKy8vlcrnCLTs7+xr/BQAAwC62B5mbbrpJR48eVW1trZYsWaKFCxeqsbHxqo9XWlqqQCAQbq2trf1YLQAAiCZxdheQkJCgz33uc5KkiRMn6tChQ/r+97+vr3zlK7pw4YLa29sjzsr4/X55PJ5ej+d0OuV0Oq912QAAIArYfkbmo0KhkLq6ujRx4kTFx8erqqoqPNbU1KSWlhZ5vV4bKwQAANHC1jMypaWlmjlzpnJyctTR0aFdu3bpF7/4hfbt2yeXy6VFixZpxYoVSktLU0pKih566CF5vd4+P7EEAAAGN1uDzJkzZ/T3f//3amtrk8vl0vjx47Vv3z7dddddkqSnnnpKMTExKioqUldXlwoLC7V582Y7SwYAAFEk6vaR6W/sIwMAgHmM20cGAADgShFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYy/afKABgpu6QpbrmszrT0amM5ERNzk1TbIzD7rIADDEEGQBXrLKhTWsrGtUW6Az3ZboStWZ2vmaMy7SxMgBDDZeWAFyRyoY2Ldl5JCLESJIv0KklO4+osqHNpsoADEUEGQB91h2ytLaiUT1tB36pb21Fo7pDg3rDcABRhCADoM/qms9edibmwyxJbYFO1TWfHbiiAAxpBBkAfXamo/cQczXzAODTIsgA6LOM5MR+nQcAnxZBBkCfTc5NU6YrUb09ZO3QB08vTc5NG8iyAAxhBBkAfRYb49Ca2fmSdFmYufR6zex89pMBMGAIMgCuyIxxmdqyYII8rsjLRx5XorYsmMA+MgAGFBviAbhiM8Zl6q58Dzv7ArAdQQbAVYmNcch7Y7rdZQAY4ri0BAAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADCWrUGmvLxct912m5KTk5WRkaE5c+aoqakpYk5nZ6eKi4uVnp6u4cOHq6ioSH6/36aKAQBANLE1yFRXV6u4uFgHDx7U66+/rosXL+oLX/iCzp8/H56zfPlyVVRUaM+ePaqurtbp06c1d+5cG6sGAADRwmFZlmV3EZf88Y9/VEZGhqqrq/VXf/VXCgQCGjlypHbt2qV77rlHknT8+HGNHTtWNTU1mjp16iceMxgMyuVyKRAIKCUl5Vr/CQAAoB/09fs7qu6RCQQCkqS0tDRJUn19vS5evKiCgoLwnLy8POXk5KimpqbHY3R1dSkYDEY0AAAwOEVNkAmFQiopKdG0adM0btw4SZLP51NCQoJSU1Mj5rrdbvl8vh6PU15eLpfLFW7Z2dnXunQAAGCTqAkyxcXFamho0O7duz/VcUpLSxUIBMKttbW1nyoEAADRJs7uAiRp6dKleu211/TLX/5S1113Xbjf4/HowoULam9vjzgr4/f75fF4ejyW0+mU0+m81iUDAIAoYOsZGcuytHTpUr3yyivav3+/cnNzI8YnTpyo+Ph4VVVVhfuamprU0tIir9c70OUCAIAoY+sZmeLiYu3atUuvvvqqkpOTw/e9uFwuJSUlyeVyadGiRVqxYoXS0tKUkpKihx56SF6vt09PLAEAgMHN1sevHQ5Hj/3bt2/X/fffL+mDDfEefvhhvfTSS+rq6lJhYaE2b97c66Wlj+LxawAAzNPX7++o2kfmWiDIAABgHiP3kQEAALgSBBkAAGAsggwAADAWQQYAABiLIAMAAIxFkAEAAMYiyAAAAGMRZAAAgLEIMgAAwFgEGQAAYCyCDAAAMBZBBgAAGIsgAwAAjEWQAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADAWQQYAABgrzu4CTNQdslTXfFZnOjqVkZyoyblpio1x2F0WAABDDkHmClU2tGltRaPaAp3hvkxXotbMzteMcZk2VgYAwNDDpaUrUNnQpiU7j0SEGEnyBTq1ZOcRVTa02VQZAABDE0Gmj7pDltZWNMrqYexS39qKRnWHepoBAACuBYJMH9U1n73sTMyHWZLaAp2qaz47cEUBADDEEWT66ExH7yHmauYBAIBPz9Yg88tf/lKzZ89WVlaWHA6H9u7dGzFuWZZWr16tzMxMJSUlqaCgQCdPnrSl1ozkxH6dBwAAPj1bg8z58+f153/+59q0aVOP4xs2bNDGjRu1detW1dbWatiwYSosLFRn58Cf9Zicm6ZMV6J6e8jaoQ+eXpqcmzaQZQEAMKTZ+vj1zJkzNXPmzB7HLMvS008/rX/6p3/S3XffLUn60Y9+JLfbrb1792revHk9vq+rq0tdXV3h18FgsF9qjY1xaM3sfC3ZeUQOKeKm30vhZs3sfPaTAQBgAEXtPTLNzc3y+XwqKCgI97lcLk2ZMkU1NTW9vq+8vFwulyvcsrOz+62mGeMytWXBBHlckZePPK5EbVkwgX1kAAAYYFG7IZ7P55Mkud3uiH632x0e60lpaalWrFgRfh0MBvs9zNyV72FnXwAAokDUBpmr5XQ65XQ6r+lnxMY45L0x/Zp+BgAA+GRRe2nJ4/FIkvx+f0S/3+8PjwEAgKEtaoNMbm6uPB6Pqqqqwn3BYFC1tbXyer02VgYAAKKFrZeWzp07p1OnToVfNzc36+jRo0pLS1NOTo5KSkr0+OOPa8yYMcrNzVVZWZmysrI0Z84c+4oGAABRw9Ygc/jwYf31X/91+PWlm3QXLlyoHTt2aOXKlTp//rwWL16s9vZ2TZ8+XZWVlUpMZNM5AAAgOSzLGtS/chgMBuVyuRQIBJSSkmJ3OQAAoA/6+v0dtffIAAAAfBKCDAAAMBZBBgAAGIsgAwAAjDXodvb9qEv3MvfXj0cCAIBr79L39ic9kzTog0xHR4ck9evvLQEAgIHR0dEhl8vV6/igf/w6FAqpqalJ+fn5am1t5RHsKHfpRz5ZKzOwXuZgrczBWn3Asix1dHQoKytLMTG93wkz6M/IxMTEaNSoUZKklJSUIf0fhUlYK7OwXuZgrczBWuljz8Rcws2+AADAWAQZAABgrCERZJxOp9asWSOn02l3KfgErJVZWC9zsFbmYK2uzKC/2RcAAAxeQ+KMDAAAGJwIMgAAwFgEGQAAYCyCDAAAMNagDzKbNm3S9ddfr8TERE2ZMkV1dXV2lwRJ5eXluu2225ScnKyMjAzNmTNHTU1NEXM6OztVXFys9PR0DR8+XEVFRfL7/TZVjEvWr18vh8OhkpKScB9rFT3efvttLViwQOnp6UpKStItt9yiw4cPh8cty9Lq1auVmZmppKQkFRQU6OTJkzZWPHR1d3errKxMubm5SkpK0o033qjHHnss4reFWK8+sAax3bt3WwkJCdYPf/hD6ze/+Y319a9/3UpNTbX8fr/dpQ15hYWF1vbt262Ghgbr6NGj1he/+EUrJyfHOnfuXHjOgw8+aGVnZ1tVVVXW4cOHralTp1q33367jVWjrq7Ouv76663x48dby5YtC/ezVtHh7Nmz1ujRo63777/fqq2ttd566y1r37591qlTp8Jz1q9fb7lcLmvv3r3WsWPHrL/5m7+xcnNzrffee8/GyoemdevWWenp6dZrr71mNTc3W3v27LGGDx9uff/73w/PYb0+2aAOMpMnT7aKi4vDr7u7u62srCyrvLzcxqrQkzNnzliSrOrqasuyLKu9vd2Kj4+39uzZE57z29/+1pJk1dTU2FXmkNbR0WGNGTPGev31163Pf/7z4SDDWkWPb3/729b06dN7HQ+FQpbH47G++93vhvva29stp9NpvfTSSwNRIj5k1qxZ1gMPPBDRN3fuXGv+/PmWZbFefTVoLy1duHBB9fX1KigoCPfFxMSooKBANTU1NlaGngQCAUlSWlqaJKm+vl4XL16MWL+8vDzl5OSwfjYpLi7WrFmzItZEYq2iyU9+8hNNmjRJ9957rzIyMnTrrbfqueeeC483NzfL5/NFrJXL5dKUKVNYKxvcfvvtqqqq0okTJyRJx44d04EDBzRz5kxJrFdfDdofjfzf//1fdXd3y+12R/S73W4dP37cpqrQk1AopJKSEk2bNk3jxo2TJPl8PiUkJCg1NTVirtvtls/ns6HKoW337t06cuSIDh06dNkYaxU93nrrLW3ZskUrVqzQP/zDP+jQoUP61re+pYSEBC1cuDC8Hj39f5G1GnirVq1SMBhUXl6eYmNj1d3drXXr1mn+/PmSxHr10aANMjBHcXGxGhoadODAAbtLQQ9aW1u1bNkyvf7660pMTLS7HHyMUCikSZMm6YknnpAk3XrrrWpoaNDWrVu1cOFCm6vDR7388st68cUXtWvXLt188806evSoSkpKlJWVxXpdgUF7aemzn/2sYmNjL3tywu/3y+Px2FQVPmrp0qV67bXX9POf/1zXXXdduN/j8ejChQtqb2+PmM/6Dbz6+nqdOXNGEyZMUFxcnOLi4lRdXa2NGzcqLi5ObrebtYoSmZmZys/Pj+gbO3asWlpaJCm8Hvx/MTo8+uijWrVqlebNm6dbbrlFf/d3f6fly5ervLxcEuvVV4M2yCQkJGjixImqqqoK94VCIVVVVcnr9dpYGaQPHilcunSpXnnlFe3fv1+5ubkR4xMnTlR8fHzE+jU1NamlpYX1G2B33nmn3nzzTR09ejTcJk2apPnz54f/zVpFh2nTpl22jcGJEyc0evRoSVJubq48Hk/EWgWDQdXW1rJWNnj33XcVExP5NRwbG6tQKCSJ9eozu+82vpZ2795tOZ1Oa8eOHVZjY6O1ePFiKzU11fL5fHaXNuQtWbLEcrlc1i9+8Qurra0t3N59993wnAcffNDKycmx9u/fbx0+fNjyer2W1+u1sWpc8uGnliyLtYoWdXV1VlxcnLVu3Trr5MmT1osvvmh95jOfsXbu3Bmes379eis1NdV69dVXrV//+tfW3XffzeO8Nlm4cKE1atSo8OPXP/7xj63Pfvaz1sqVK8NzWK9PNqiDjGVZ1jPPPGPl5ORYCQkJ1uTJk62DBw/aXRIsy5LUY9u+fXt4znvvvWd985vftEaMGGF95jOfsb785S9bbW1t9hWNsI8GGdYqelRUVFjjxo2znE6nlZeXZz377LMR46FQyCorK7PcbrfldDqtO++802pqarKp2qEtGAxay5Yts3JycqzExETrhhtusP7xH//R6urqCs9hvT6Zw7I+tIUgAACAQQbtPTIAAGDwI8gAAABjEWQAAICxCDIAAMBYBBkAAGAsggwAADAWQQYAABiLIAMAAIxFkAEAAMYiyAAwUk1NjWJjYzVr1iy7SwFgI36iAICRvva1r2n48OHatm2bmpqalJWVZXdJAGzAGRkAxjl37pz+/d//XUuWLNGsWbO0Y8cOu0sCYBOCDADjvPzyy8rLy9NNN92kBQsW6Ic//KE4uQwMTQQZAMbZtm2bFixYIEmaMWOGAoGAqqurba4KgB24RwaAUZqamjRu3Di9/fbbysjIkCQtXbpUgUBAL7zwgs3VARhocXYXAABXYtu2bXr//fcjbu61LEtOp1M/+MEP5HK5bKwOwEDj0hIAY7z//vv60Y9+pO9973s6evRouB07dkxZWVl66aWX7C4RwADj0hIAY+zdu1df+cpXdObMmcvOvHz729/W/v37dejQIZuqA2AHggwAY8yePVuhUEj/8R//cdlYXV2dpkyZomPHjmn8+PE2VAfADgQZAABgLO6RAQAAxiLIAAAAYxFkAACAsQgyAADAWAQZAABgLIIMAAAwFkEGAAAYiyADAACMRZABAADGIsgAAABjEWQAAICx/h8sdgKgggWwSwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 调用scatter_matrix函数\n", + "scatter_matrix(data)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 使用 pandas 自带的绘制散点图矩阵(示例)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "scatter_matrix `是一个用于绘制多个变量之间散点图矩阵的函数，其主要参数如下`: \n", + "\n", + "- frame: DataFrame对象，包含待绘制散点图的数据\n", + "- alpha: 点透明度，取值范围为[0, 1]\n", + "- figsize: 图像尺寸，形式为元组，例如(10, 10)\n", + "- diagonal: 设置对角线上的单变量分布图，可以选择'hist'或'kde'\n", + "- marker: 散点的标记样式，默认为'o'，还可以使用其他的标记样式，例如\".\"、\"+\"等\n", + "- density_kwds: 字典类型，传递给核密度估计图(kde)的参数设置\n", + "- hist_kwds: 字典类型，传递给直方图(hist)的参数设置\n", + "- range_padding: 控制图像中每个小图与边界的距离\n", + "- label: 可以是字符串或数组，包含每个小图的标签名称\n", + "- color: 指定散点的颜色，可以是单一整数或字符串，也可以通过传递列表来指定每个数据集的颜色\n", + "需要注意的是，scatter_matrix 默认会针对每个特征之间的组合绘制散点图，因此如果传入的特征数量较多，那么将会产生大量图像，可能会导致绘图效率和可读性降低。因此在实际使用时需要根据数据集的大小和特征数量进行选择和调整。\n", + "\n", + "语法:\n", + "```py\n", + "pandas.plotting.scatter_matrix(frame, alpha=0.5, figsize=None, ax=None, diagonal='hist', marker='.', density_kwds=None, hist_kwds=None, range_padding=0.05, **kwargs)\n", + "```\n", + "其中，必选参数 `frame` 表示待绘制散点图的数据集。\n", + "\n", + "可选参数包括: \n", + "\n", + "- `alpha`: 点透明度，默认为 0.5。\n", + "- `figsize`: 绘图尺寸，形式为元组，例如 (10, 10)。\n", + "- `ax`: 指定绘图使用的坐标轴对象，如果没有指定则使用当前坐标轴。\n", + "- `diagonal`: 对角线上的单变量分布图，可以选择 'hist' 或 'kde'。\n", + "- `marker`: 散点的标记样式，默认为 '.'，还可以使用其他的标记样式，例如 \".\"、\"+\" 等。\n", + "- `density_kwds`: 字典类型，传递给核密度估计图(kde)的参数设置。\n", + "- `hist_kwds`: 字典类型，传递给直方图(hist)的参数设置。\n", + "- `range_padding`: 控制图像中每个小图与边界的距离。\n", + "- `**kwargs`: 其他关键字参数，比如颜色等。具体有\n", + " - `c`: 用于指定散点的颜色，可以是单一整数或字符串，也可以通过传递列表来指定每个数据集的颜色。\n", + " - `s`: 用于指定散点的大小，默认为 20。\n", + " - `cmap`: 用于指定颜色映射的名称，默认为 \"viridis\"。\n", + " - `norm`: 用于归一化颜色数据的方法。\n", + " - `vmin`, `vmax`: 用于指定颜色显示的最小值和最大值。\n", + " - `linewidths`: 用于指定散点边界的线宽，默认为 None。\n", + " - `edgecolors`: 用于指定散点边界的颜色，默认为 None。\n", + " - `label`: 可以是字符串或数组，包含每个小图的标签名称。\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pandas.plotting import scatter_matrix\n", + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 创建一个 DataFrame 对象，包含两个特征 'x' 和 'y'\n", + "data = pd.DataFrame(np.random.randn(100, 2), columns=['x', 'y'])\n", + "\n", + "# 使用 scatter_matrix 函数创建散点图矩阵\n", + "scatter_matrix(data, alpha=0.2, figsize=(6, 6), diagonal='hist')\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/05 \346\212\230\347\272\277\345\233\276.ipynb" "b/python/old-note-py-pyData/Example/05 \346\212\230\347\272\277\345\233\276.ipynb" new file mode 100644 index 0000000..da35ef8 --- /dev/null +++ "b/python/old-note-py-pyData/Example/05 \346\212\230\347\272\277\345\233\276.ipynb" @@ -0,0 +1,301 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# 指定绘图时使用的无衬线字体为 SimHei。 plt 绘图时, 默认无法绘制中文字体。\n", + "# plt.rcParams['font.sans-serif'] = ['SimHei'] \n", + "# 也可以直接指定字体族\n", + "# plt.rcParams['font.family'] = 'SimHei'\n", + "\n", + "# 'SimHei' 无法显示负号, 'Arial' 无法显示中文, 两个一起就可以互补\n", + "plt.rcParams['font.family'] = ['Arial', 'SimHei']\n", + "# plt.rcParams['font.family'] = ['Microsoft YaHei'] 或者直接使用 'Microsoft YaHei' 解决所有问题" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 简单示例" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 数据准备\n", + "x = [1, 2, 3, 4, 5]\n", + "y = [2, 4, 6, 8, 10]\n", + "\n", + "# 绘制折线图\n", + "plt.plot(x, y)\n", + "\n", + "# 设置图形标题和坐标轴标签\n", + "plt.title(\"Example Line Plot\")\n", + "plt.xlabel(\"X-axis label\")\n", + "plt.ylabel(\"Y-axis label\")\n", + "\n", + "# 显示图形\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 随机生成数据" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 随机生成数据\n", + "x = list(range(10))\n", + "y = [random.randint(1, 10) for i in x]\n", + "\n", + "# 绘制折线图\n", + "plt.plot(x, y)\n", + "\n", + "# 设置图形标题和坐标轴标签\n", + "plt.title(\"Example Line Plot\")\n", + "plt.xlabel(\"X-axis label\")\n", + "plt.ylabel(\"Y-axis label\")\n", + "\n", + "# 显示图形\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 介绍 plot()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`plt.plot()` 是 Matplotlib 中用于绘制折线图的函数。它的基本语法如下:\n", + "\n", + "```py\n", + "plt.plot(x, y, fmt, **kwargs)\n", + "```\n", + "\n", + "- `x` 和 `y` 分别是用于绘制折线图的数据, 可以是列表、Numpy 数组或 Pandas Series 对象; \n", + "- `fmt` 用于定义线条的样式字符串。 这个字符串包含一个或多个单字符代码，每个代码控制一种属性，例如颜色、线型和标记类型等\n", + "- `kwargs` 是一个字典, 用于指定其他绘图参数, 例如标题、坐标轴标签和注释等。\n", + "\n", + "`fmt` 控制颜色的字符串有:\n", + "\n", + "- `'b'`: 蓝色\n", + "- `'g'`: 绿色\n", + "- `'r'`: 红色\n", + "- `'c'`: 青色（蓝绿色）\n", + "- `'m'`: 洋红色（品红色）\n", + "- `'y'`: 黄色\n", + "- `'k'`: 黑色\n", + "- `'w'`: 白色\n", + "\n", + "`fmt` 控制线条形状的字符串有:\n", + "\n", + "- `'-'`: 实线（默认）\n", + "- `'--'`: 虚线\n", + "- `'-.'`: 点划线\n", + "- `':'`: 点线\n", + "- `'_'`: 水平线条\n", + "\n", + "`fmt` 控制每个点标记类型的字符串有:\n", + "\n", + "- `'.'`: 小圆点\n", + "- `','`: 像素点标记\n", + "- `'o'`: 圆圈标记\n", + "- `'v'`: 倒三角形标记\n", + "- `'^'`: 正三角形标记\n", + "- `'<'`: 左三角形标记\n", + "- `'>'`: 右三角形标记\n", + "- `'1'`: 下花心标记\n", + "- `'2'`: 上花心标记\n", + "- `'3'`: 左花心标记\n", + "- `'4'`: 右花心标记\n", + "- `'s'`: 正方形标记\n", + "- `'p'`: 五边形标记\n", + "- `'*'`: 星号标记\n", + "- `'h'`: 六边形1标记\n", + "- `'H'`: 六边形2标记\n", + "- `'+'`: 加号标记\n", + "- `'x'`: 叉号标记\n", + "- `'D'`: 菱形标记\n", + "- `'d'`: 小菱形标记\n", + "\n", + "上面介绍的三类 `fmt` 可以组合使用, 比如 `'r--H'`。\n", + "\n", + "其实 `fmt` 是一种简便的写法, 也可以不使用 `fmt`, 而是使用 `kwargs` 来定义。\n", + "常见的 `kwargs` 有:\n", + "\n", + "- `color`: 线条颜色\n", + "- `linestyle`, `ls`: 线型\n", + " - `linewidth`, `lw`: 线宽\n", + "- `marker`: 标记类型\n", + " - `markersize`, `ms`: 标记大小\n", + " - `markeredgewidth`: 标记宽度\n", + " - `markeredgecolor`: 标记颜色\n", + "- `label`: 添加一个图例标签，用于区分不同的曲线。" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 随机生成数据\n", + "x = list(range(10))\n", + "y = [random.randint(1, 10) for i in x]\n", + "\n", + "# 绘制折线图\n", + "plt.plot(x, y, 'r--o')\n", + "\n", + "# 设置图形标题和坐标轴标签\n", + "plt.title(\"Example Line Plot\")\n", + "plt.xlabel(\"X-axis label\")\n", + "plt.ylabel(\"Y-axis label\")\n", + "\n", + "# 显示图形\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 绘制多条曲线" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 生成 x 坐标轴数据\n", + "x = np.linspace(0, 2*np.pi, 100)\n", + "\n", + "# 生成 y 坐标轴数据\n", + "y1 = np.sin(x)\n", + "y2 = np.cos(x)\n", + "\n", + "# 绘制两条曲线\n", + "plt.plot(x, y1, label='sin 曲线')\n", + "plt.plot(x, y2, label='cos 曲线')\n", + "\n", + "# 添加标题和图例\n", + "plt.title('Sine and Cosine')\n", + "plt.legend()\n", + "\n", + "# 显示图形\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/06 \347\256\261\345\236\213\345\233\276.ipynb" "b/python/old-note-py-pyData/Example/06 \347\256\261\345\236\213\345\233\276.ipynb" new file mode 100644 index 0000000..d8e7797 --- /dev/null +++ "b/python/old-note-py-pyData/Example/06 \347\256\261\345\236\213\345\233\276.ipynb" @@ -0,0 +1,380 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`boxplot()` 用于绘制箱线图。\n", + "\n", + "箱线图由五个数值点组成: 最小值, 下四分位数, 中位数, 上四分位数, 最大值。\n", + "\n", + "下四分位数、中位数、上四分位数组成一个“带有隔间的盒子”, 也可以往盒子里面加入平均值。\n", + "箱子两侧的延伸线称为“胡须(whisker)”, 揭示数据的范围, “胡须”外部的点称为离群点。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`boxplot()` 参数很多, 下面只是一部分参数:\n", + "\n", + "```py\n", + "plt.boxplot(x, labels=None,\n", + " notch=None, sym=None, vert=None,\n", + " whis=None, positions=None, widths=None,\n", + " patch_artist=None, meanline=None, showmeans=None,\n", + " showcaps=None, showbox=None, showfliers=None)\n", + "```\n", + "- `x` 指定要绘制箱线图的数据, 可以是一个数组, 或一个数组序列\n", + "- `labels` 为箱线图添加标签, 类似于图例的作用。\n", + "- `notch` 表示是否取凹口的形式展现箱线图, 默认非凹口\n", + "- `sym` 用于指定异常点的形状\n", + "- `vert` 表示是否将箱线图垂直摆放, 默认为垂直摆放\n", + "- `whis` 指定上下须与上下四分位的距离, 默认为1.5倍的四分位间距\n", + "- `positions` 指定箱线图的位置, 默认为 [0,1,2, …] \n", + "- `widths` 指定箱线图的宽度\n", + "- `patch_artist` 表示是否填充箱体的颜色\n", + "- `meanline` 表示是否用线的形式表示均值, 默认用点来表示\n", + "- `showmeans` 表示是否显示均值, 默认不显示\n", + "- `showcaps` 表示是否显示箱线图顶端和末端的两条线, 默认显示\n", + "- `showbox` 表示是否显示箱线图的箱体, 默认显示\n", + "- `showfliers` 表示是否显示离群值, 默认显示" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 例1\n", + "以下是已经过排序的8个病人的血压（mmHg）数据，试画出箱线图。\n", + "\n", + " 102, 110, 117, 118, 122, 123, 132, 150" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X_mmHg = [102, 110, 117, 118, 122, 123, 132, 150]\n", + "# 绘制箱线图\n", + "plt.boxplot(X_mmHg, labels=['mmHg'])\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 例2\n", + "\n", + "下面给出了25个男子和25个女子的肺活量（已排序）。\n", + "\n", + "女子组\n", + "\n", + " 2.7, 2.8, 2.9, 3.1, 3.1, 3.1, 3.2, 3.4, 3.4,\n", + " 3.4, 3.4, 3.4, 3.5, 3.5, 3.5, 3.6, 3.7, 3.7,\n", + " 3.7, 3.8, 3.8, 4.0, 4.1, 4.2, 4.2\n", + " \n", + "男子组\n", + "\n", + " 4.1, 4.1, 4.3, 4.3, 4.5, 4.6, 4.7, 4.8, 4.8,\n", + " 5.1, 5.3, 5.3, 5.3, 5.4, 5.4, 5.5, 5.6, 5.7,\n", + " 5.8, 5.8, 6.0, 6.1, 6.3, 6.7, 6.7" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X_F = [2.7, 2.8, 2.9, 3.1, 3.1, 3.1, 3.2, 3.4, 3.4,\n", + " 3.4, 3.4, 3.4, 3.5, 3.5, 3.5, 3.6, 3.7, 3.7,\n", + " 3.7, 3.8, 3.8, 4.0, 4.1, 4.2, 4.2]\n", + "X_M = [4.1, 4.1, 4.3, 4.3, 4.5, 4.6, 4.7, 4.8, 4.8,\n", + " 5.1, 5.3, 5.3, 5.3, 5.4, 5.4, 5.5, 5.6, 5.7,\n", + " 5.8, 5.8, 6.0, 6.1, 6.3, 6.7, 6.7]\n", + "X = [X_F, X_M]\n", + "plt.boxplot(X, labels=['female', 'male'])\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 例3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "plt.rcParams['font.family'] = ['SimHei']" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "X = [[4.3 , 3.55, 3.9 , 4.5 ],\n", + " [4. , 3.75, 3.55, 4.5 ],\n", + " [4.5 , 4.05, 3.9 , 4.5 ],\n", + " [4.2 , 2.35, 2.7 , 4.5 ],\n", + " [1.4 , 1.7 , 2.55, 3. ],\n", + " [3.1 , 3.4 , 3.6 , 4. ],\n", + " [2.65, 3.8 , 3.45, 3.5 ],\n", + " [3.2 , 3.4 , 3.25, 3.5 ],\n", + " [4.1 , 4.4 , 3.7 , 4. ],\n", + " [4.35, 4.25, 3.9 , 4. ],\n", + " [3.85, 3.75, 3.6 , 4. ],\n", + " [3. , 3.3 , 3.2 , 3.5 ],\n", + " [3.95, 3.6 , 3.85, 3.5 ],\n", + " [3.5 , 3.25, 3.6 , 4.1 ],\n", + " [4.6 , 4.1 , 4.05, 4.6 ],\n", + " [2.3 , 2.3 , 3.05, 4.1 ],\n", + " [2.9 , 3.25, 3.3 , 4.1 ],\n", + " [4. , 4.1 , 3.9 , 4.6 ],\n", + " [2.9 , 2.9 , 3.15, 4.1 ],\n", + " [2.7 , 2.65, 2.8 , 4.1 ],\n", + " [4.45, 3.6 , 3.75, 4.6 ],\n", + " [2.8 , 3.45, 3.15, 4.1 ],\n", + " [4. , 3.95, 3.8 , 4.1 ],\n", + " [2.95, 3.65, 3.3 , 4.1 ],\n", + " [3.7 , 3. , 3.35, 4.1 ],\n", + " [4.3 , 3.55, 3.75, 4.6 ],\n", + " [4.3 , 3.95, 3.85, 4.1 ],\n", + " [4.25, 3.9 , 3.75, 4.1 ],\n", + " [4.6 , 4.4 , 4.1 , 4.1 ],\n", + " [4.45, 3.75, 3.95, 4.1 ],\n", + " [4.3 , 3.7 , 3.85, 4.1 ],\n", + " [4.45, 3.2 , 3.9 , 4.1 ],\n", + " [3.6 , 3.9 , 3.75, 4.1 ],\n", + " [1.75, 2.75, 2.3 , 3.6 ],\n", + " [1.55, 2. , 2.75, 3.1 ],\n", + " [2. , 1.2 , 3.15, 3.6 ],\n", + " [2.35, 3.4 , 3.05, 3.6 ],\n", + " [2.35, 3.45, 2.95, 3.6 ],\n", + " [2.25, 3.4 , 3.15, 3.1 ],\n", + " [2.3 , 2.9 , 3.15, 3.1 ],\n", + " [3.5 , 3.45, 3.45, 3.6 ],\n", + " [3.9 , 3.45, 3.6 , 3.6 ],\n", + " [4.3 , 4.8 , 4.1 , 3.6 ],\n", + " [4.05, 3.15, 3.5 , 3.6 ],\n", + " [4.2 , 3.95, 3.9 , 4.2 ],\n", + " [2.65, 3.2 , 3.3 , 3.7 ],\n", + " [3.05, 2.7 , 3.2 , 4.2 ],\n", + " [3.05, 2.4 , 2.6 , 4.2 ],\n", + " [1. , 1.25, 2. , 2.7 ],\n", + " [3. , 3.2 , 3.45, 4.2 ],\n", + " [3.4 , 2.85, 3.35, 4.2 ],\n", + " [3.4 , 2.6 , 3.55, 4.2 ],\n", + " [3.4 , 3.7 , 3.65, 4.2 ],\n", + " [1.85, 1.85, 2.45, 3.7 ],\n", + " [3.4 , 3.2 , 3.3 , 4.2 ],\n", + " [3.4 , 3.95, 3.3 , 4.2 ],\n", + " [2.3 , 2.7 , 3.2 , 3.7 ],\n", + " [2.65, 3.5 , 3.1 , 3.7 ],\n", + " [1.75, 1.95, 2.75, 3.2 ],\n", + " [1.5 , 1.6 , 2.75, 3.2 ],\n", + " [1.35, 1.9 , 2.7 , 3.2 ],\n", + " [2.6 , 3.4 , 3.25, 3.7 ],\n", + " [2.05, 2.85, 3.15, 3.2 ],\n", + " [2.2 , 2.65, 3.2 , 3.7 ],\n", + " [1.65, 3.95, 3.15, 3.7 ],\n", + " [3.9 , 4. , 3.95, 3.7 ],\n", + " [3.95, 4.15, 3.8 , 3.7 ],\n", + " [1.95, 2.9 , 2.95, 2.7 ],\n", + " [3.85, 3.75, 3.65, 4.2 ],\n", + " [2.8 , 3.3 , 3.45, 3.2 ],\n", + " [4.35, 3. , 3.85, 4.2 ],\n", + " [4.2 , 3.5 , 3.9 , 4.2 ],\n", + " [4.25, 3.3 , 3.7 , 4.8 ],\n", + " [4.2 , 3.4 , 3.7 , 4.8 ],\n", + " [3.75, 3.5 , 3.75, 4.3 ],\n", + " [2.9 , 2.75, 3.25, 4.3 ],\n", + " [4.7 , 3.65, 4.2 , 4.8 ],\n", + " [2.75, 3.1 , 3.15, 3.8 ],\n", + " [2.85, 3.7 , 3.5 , 3.8 ],\n", + " [1.2 , 1.85, 2.5 , 2.8 ],\n", + " [2.85, 3.1 , 3.45, 3.8 ],\n", + " [3.45, 3.75, 3.5 , 3.8 ],\n", + " [1.25, 2.7 , 2.7 , 2.8 ],\n", + " [2.55, 4.2 , 3.3 , 3.8 ],\n", + " [1.7 , 2.5 , 2.75, 3.3 ],\n", + " [4.05, 2.95, 3.7 , 4.3 ],\n", + " [4.45, 4.2 , 4.1 , 4.3 ],\n", + " [1.6 , 3.25, 2.8 , 3.3 ],\n", + " [4.4 , 4.35, 4.15, 4.3 ],\n", + " [4.1 , 3.15, 3.65, 4.3 ],\n", + " [2.75, 3.25, 3.05, 3.3 ],\n", + " [4.05, 4.1 , 3.6 , 4.3 ],\n", + " [4.3 , 3.6 , 3.75, 4.3 ],\n", + " [4.3 , 4.15, 3.8 , 4.3 ],\n", + " [3.25, 4.3 , 3.45, 3.3 ],\n", + " [4.5 , 3.9 , 4.2 , 4.3 ],\n", + " [4.6 , 4.1 , 4.1 , 4.3 ],\n", + " [2.1 , 1.6 , 2.1 , 3.9 ],\n", + " [2.4 , 1.9 , 3.05, 3.9 ],\n", + " [2.7 , 3.1 , 3.3 , 3.9 ],\n", + " [2. , 2.25, 2.75, 3.4 ],\n", + " [1.35, 3.5 , 2.2 , 2.9 ],\n", + " [3.15, 3.05, 3.3 , 3.9 ],\n", + " [2.5 , 2.65, 2.85, 3.4 ],\n", + " [1.7 , 2.15, 2.9 , 3.4 ],\n", + " [2.45, 1.65, 2.95, 3.9 ],\n", + " [2.35, 3.2 , 3.25, 3.4 ],\n", + " [1.05, 2.7 , 2.3 , 2.9 ],\n", + " [2.35, 3.5 , 3.2 , 3.9 ],\n", + " [3.45, 2.3 , 3.55, 3.9 ],\n", + " [2.6 , 3.45, 3.3 , 3.9 ],\n", + " [2.5 , 3.05, 3. , 3.4 ],\n", + " [3.25, 3.75, 3.45, 2.9 ],\n", + " [2.6 , 3.7 , 3.35, 2.9 ],\n", + " [3.45, 3.5 , 3.55, 3.4 ],\n", + " [2.6 , 3.35, 3.2 , 2.9 ],\n", + " [3.35, 3.55, 3.4 , 3.4 ],\n", + " [3.95, 3.95, 3.65, 3.9 ],\n", + " [3.8 , 3.95, 3.6 , 3.9 ],\n", + " [4.05, 4. , 3.6 , 3.4 ],\n", + " [3.65, 3.5 , 3.55, 3.4 ],\n", + " [4.35, 4.25, 3.55, 3.9 ],\n", + " [4.3 , 3.65, 3.7 , 3.9 ],\n", + " [3.2 , 2.7 , 3.15, 4.4 ],\n", + " [3.25, 3.65, 3.35, 4.4 ],\n", + " [3.3 , 1.65, 3.35, 4.4 ],\n", + " [4.05, 3.6 , 3.7 , 4.4 ],\n", + " [3. , 3.45, 3. , 4.4 ],\n", + " [4.5 , 4. , 3.9 , 4.4 ],\n", + " [4.55, 4.4 , 4. , 4.4 ],\n", + " [4.05, 3.5 , 3.65, 4.5 ],\n", + " [2.6 , 2.85, 3.35, 4. ],\n", + " [3.65, 2.95, 3.5 , 4.5 ],\n", + " [1.8 , 1.2 , 2.15, 3.5 ],\n", + " [3.65, 2.4 , 3.6 , 4.5 ],\n", + " [1.15, 2.45, 2.6 , 3. ],\n", + " [1.25, 2.2 , 2.45, 3. ],\n", + " [3.75, 3.55, 3.55, 4. ],\n", + " [4.15, 3.55, 3.6 , 4.5 ],\n", + " [1.25, 2.65, 2.7 , 3. ],\n", + " [4.5 , 4.45, 4.3 , 4.5 ],\n", + " [3.9 , 3.95, 3.7 , 4. ],\n", + " [4.1 , 3.75, 3.6 , 3.5 ],\n", + " [3.9 , 4.4 , 3.7 , 3.5 ],\n", + " [4.05, 3.65, 3.9 , 3.5 ],\n", + " [3.15, 3.2 , 3.35, 3.5 ]]\n", + "\n", + "cols=['RT_user_norm', 'Metacritic_user_nom',\n", + " 'IMDB_norm', 'Fandango_Ratingvalue']\n", + "df = pd.DataFrame(X, columns=cols)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cols=['RT_user_norm', 'Metacritic_user_nom',\n", + " 'IMDB_norm', 'Fandango_Ratingvalue']\n", + "X = df[cols].values\n", + "\n", + "# 定义离群点的样式\n", + "flierprops = dict(marker='+', markersize=10)\n", + "# 定义“胡须”的样式\n", + "whiskerprops = dict(linestyle='--', linewidth=1.5, color='red')\n", + "# 定义箱子的样式\n", + "boxprops = dict(linestyle='-', linewidth=1.5, color='blue')\n", + "\n", + "plt.boxplot(X, labels=cols, boxprops=boxprops, flierprops=flierprops, whiskerprops=whiskerprops)\n", + "\n", + "# 设置纵坐标范围\n", + "plt.ylim(0, 5)\n", + "# 横坐标标签垂直显示\n", + "plt.xticks(rotation=90, fontsize=18)\n", + "# 让四周都出现刻度, 并且刻度在内侧\n", + "plt.tick_params(axis='both', which='both', direction='in', top=True, right=True)\n", + "\n", + "# 显示图形\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/07-\347\203\255\345\212\233\345\233\276-\346\267\267\346\267\206\347\237\251\351\230\265.ipynb" "b/python/old-note-py-pyData/Example/07-\347\203\255\345\212\233\345\233\276-\346\267\267\346\267\206\347\237\251\351\230\265.ipynb" new file mode 100644 index 0000000..1e567f3 --- /dev/null +++ "b/python/old-note-py-pyData/Example/07-\347\203\255\345\212\233\345\233\276-\346\267\267\346\267\206\347\237\251\351\230\265.ipynb" @@ -0,0 +1,148 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import seaborn as sns" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`cmpa` 常见值有: 详细请参考 [官网](https://seaborn.pydata.org/tutorial/color_palettes.html)\n", + "- `\"rocket\"`\n", + "- `\"mako\"`\n", + "- `\"viridis\"`\n", + "- `\"plasma\"`\n", + "- `\"inferno\"`\n", + "- `\"cividis\"`\n", + "- `\"coolwarm\"`\n", + "- `\"YlGnBu\"`\n", + "- `\"Blues\"`\n", + "- `\"Greens\"`\n", + "- `\"Oranges\"`\n", + "- `\"Reds\"` \n", + "\n", + "`annot` 控制是否在矩阵中显示数值\n", + "\n", + "`fmt` 控制数值的格式, 比如 `'d'` 就是显示为整数。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate a sample confusion matrix\n", + "cm = [[100, 20, 30], [40, 80, 10], [5, 25, 90]]\n", + "\n", + "# Define color map\n", + "cmap = 'Blues'\n", + "\n", + "# Create heatmap with annotated values\n", + "sns.heatmap(cm, annot=True, fmt='d', cmap=cmap)\n", + "\n", + "# Show plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cm = [[100, 20, 30], [40, 80, 10], [5, 25, 90]]\n", + "\n", + "# 绘制热力图（Matplotlib）, plt 没有 annot 属性来显示数值, , 不过它也有 cmap 属性\n", + "plt.matshow(cm, cmap='Blues')\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 创建 3x3 的随机矩阵列表\n", + "matrices = [np.random.rand(3, 3) for _ in range(9)]\n", + "\n", + "j = 1\n", + "fig = plt.figure(figsize=(12, 12))\n", + "for i in range(len(matrices)):\n", + " plt.subplot(3, 3, j)\n", + " j += 1\n", + " sns.heatmap(matrices[i], annot=True, cmap='Blues')\n", + "\n", + "# 调整子图之间的间距\n", + "fig.subplots_adjust(hspace=0.4, wspace=0.4)\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/old-note-py-pyData/Example/a.ipynb b/python/old-note-py-pyData/Example/a.ipynb new file mode 100644 index 0000000..e64bab5 --- /dev/null +++ b/python/old-note-py-pyData/Example/a.ipynb @@ -0,0 +1,475 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(126, 158)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_Etruscan = np.array([141, 148, 132, 138, 154, 142, 150, 146, 155, 158,\n", + " 150, 140, 147, 148, 144, 150, 149, 145, 149, 158,\n", + " 143, 141, 144, 144, 126, 140, 144, 142, 141, 140,\n", + " 145, 135, 147, 146, 141, 136, 140, 146, 142, 137,\n", + " 148, 154, 137, 139, 143, 140, 131, 143, 141, 149,\n", + " 148, 135, 148, 152, 143, 144, 141, 143, 147, 146,\n", + " 150, 132, 142, 142, 143, 153, 149, 146, 149, 138,\n", + " 142, 149, 142, 137, 134, 144, 146, 147, 140, 142,\n", + " 140, 137, 152, 145])\n", + "# 统计数据的最小值与最大值\n", + "X_min, X_max = min(X_Etruscan), max(X_Etruscan)\n", + "X_min, X_max\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([124.5, 129.5, 134.5, 139.5, 144.5, 149.5, 154.5, 159.5])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 生成从 124.5 到 159.5(包含)距离相等的 8 个数，作为区间端点\n", + "bins = np.linspace(X_min - 1.5, X_max + 1.5, 8)\n", + "bins\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(124.499, 129.5] 1\n", + "(129.5, 134.5] 4\n", + "(134.5, 139.5] 10\n", + "(139.5, 144.5] 33\n", + "(144.5, 149.5] 24\n", + "(149.5, 154.5] 9\n", + "(154.5, 159.5] 3\n", + "dtype: int64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 以 bins 为区间端点,统计落在每个区间的数据频数\n", + "uniform_divide = pd.cut(X_Etruscan, bins, include_lowest=True).value_counts()\n", + "uniform_divide\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.0119 , 0.04762, 0.11905, 0.39286, 0.28571, 0.10714, 0.03571])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 计算频率\n", + "freq = uniform_divide.values # 每组频数\n", + "frequency = freq / sum(freq) # 频数/总个数\n", + "frequency = np.round(frequency, 5) # 保留 5 位小数\n", + "frequency\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.0119, 0.0595, 0.1786, 0.5714, 0.8571, 0.9643, 1. ])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 计算 累积频率\n", + "cumfreq = np.cumsum(frequency) # cumsum 求累积和\n", + "cumfreq = np.round(cumfreq, 4) # 保留 4 位小数\n", + "cumfreq\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FreqFrequencyCumFreq
(124.499, 129.5]10.01190.0119
(129.5, 134.5]40.04760.0595
(134.5, 139.5]100.11900.1786
(139.5, 144.5]330.39290.5714
(144.5, 149.5]240.28570.8571
(149.5, 154.5]90.10710.9643
(154.5, 159.5]30.03571.0000
\n", + "
" + ], + "text/plain": [ + " Freq Frequency CumFreq\n", + "(124.499, 129.5] 1 0.0119 0.0119\n", + "(129.5, 134.5] 4 0.0476 0.0595\n", + "(134.5, 139.5] 10 0.1190 0.1786\n", + "(139.5, 144.5] 33 0.3929 0.5714\n", + "(144.5, 149.5] 24 0.2857 0.8571\n", + "(149.5, 154.5] 9 0.1071 0.9643\n", + "(154.5, 159.5] 3 0.0357 1.0000" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 绘制频数分布表\n", + "df = pd.DataFrame()\n", + "df['Freq'] = freq # 频数\n", + "df['Frequency'] = np.round(frequency, 4) # 频率\n", + "df['CumFreq'] = cumfreq # 累积频率\n", + "df.index = uniform_divide.index # 以组限作为索引\n", + "df\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制频率直方图\n", + "import matplotlib.pyplot as plt\n", + "# hist 绘制直方图, bins 为区间端点, density=True 矩形面积表示频率, alpha 设置透明度\n", + "plt.hist(X_Etruscan, bins=bins, density=True, alpha=0.8)\n", + "plt.title('frequency histograms')\n", + "plt.xticks(bins) # 以区间端点作为 x 轴刻度\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "seaborn 是基于 matplotlib 的数据可视化库。它提供了一个高度交互式界面，用于绘制有吸引力和信息丰富的统计图形。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "# distplot 绘制直方图以及核密度估计曲线\n", + "sns.histplot(X_Etruscan, bins=bins, kde=True)\n", + "plt.title('frequency histograms')\n", + "plt.xticks(bins)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Linhieng\\AppData\\Local\\Temp\\ipykernel_13688\\1777119867.py:3: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(X_Etruscan, bins=bins, kde=False, fit=norm)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.stats import norm\n", + "# kde=False 关闭核密度估计, fit=norm 拟合正态分布相应的概率密度曲线\n", + "sns.distplot(X_Etruscan, bins=bins, kde=False, fit=norm)\n", + "plt.title('frequency histograms')\n", + "plt.xticks(bins)\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 例1\n", + "设一组容量为18的样本值如下（已经过排序）：\n", + "\n", + "122, 126, 133, 140, 145, 145, 149, 150, 157,\n", + "162, 166, 175, 177, 177, 183, 188, 199, 212\n", + "\n", + "求样本分位数： $x_{0.2}$, $x_{0.25}$, $x_{0.5}$。\n", + "\n", + "解求百分位数可使用 numpy 中的 `percentile()`, 也可使用 pandas 中的 `quantile()`。" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([142. , 145. , 159.5])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 使用 percentile() 求分位数\n", + "X = np.array([122, 126, 133, 140, 145, 145, 149, 150, 157,\n", + " 162, 166, 175, 177, 177, 183, 188, 199, 212])\n", + "np.percentile(X, q=[20, 25, 50])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X
0.20142.0
0.25145.0
0.50159.5
\n", + "
" + ], + "text/plain": [ + " X\n", + "0.20 142.0\n", + "0.25 145.0\n", + "0.50 159.5" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 将数据转为 DataFrame 形式，用 quantile() 求分位数\n", + "dfX = pd.DataFrame()\n", + "dfX['X'] = np.array([122, 126, 133, 140, 145, 145, 149, 150, 157,\n", + " 162, 166, 175, 177, 177, 183, 188, 199, 212])\n", + "dfX.quantile(q=[0.2, 0.25, 0.5]) # 分位数的表示形式与 percentile() 不同\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/old-note-py-pyData/Example/case01 - \347\224\273\347\275\221\346\240\274, \345\271\266\347\273\231\345\207\272\350\276\271\347\225\214.ipynb" "b/python/old-note-py-pyData/Example/case01 - \347\224\273\347\275\221\346\240\274, \345\271\266\347\273\231\345\207\272\350\276\271\347\225\214.ipynb" new file mode 100644 index 0000000..772885d --- /dev/null +++ "b/python/old-note-py-pyData/Example/case01 - \347\224\273\347\275\221\346\240\274, \345\271\266\347\273\231\345\207\272\350\276\271\347\225\214.ipynb" @@ -0,0 +1,174 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 17., 15., 100., 102.],\n", + " [ 17., 15., 102., 104.],\n", + " [ 17., 15., 104., 106.],\n", + " [ 17., 15., 106., 108.],\n", + " [ 17., 15., 108., 110.],\n", + " [ 17., 15., 110., 112.],\n", + " [ 17., 15., 112., 114.],\n", + " [ 17., 15., 114., 116.],\n", + " [ 17., 15., 116., 118.],\n", + " [ 17., 15., 118., 120.],\n", + " [ 17., 15., 120., 122.],\n", + " [ 17., 15., 122., 124.],\n", + " [ 17., 15., 124., 126.],\n", + " [ 19., 17., 100., 102.],\n", + " [ 19., 17., 102., 104.],\n", + " [ 19., 17., 104., 106.],\n", + " [ 19., 17., 106., 108.],\n", + " [ 19., 17., 108., 110.],\n", + " [ 19., 17., 110., 112.],\n", + " [ 19., 17., 112., 114.],\n", + " [ 19., 17., 114., 116.],\n", + " [ 19., 17., 116., 118.],\n", + " [ 19., 17., 118., 120.],\n", + " [ 19., 17., 120., 122.],\n", + " [ 19., 17., 122., 124.],\n", + " [ 19., 17., 124., 126.],\n", + " [ 21., 19., 100., 102.],\n", + " [ 21., 19., 102., 104.],\n", + " [ 21., 19., 104., 106.],\n", + " [ 21., 19., 106., 108.],\n", + " [ 21., 19., 108., 110.],\n", + " [ 21., 19., 110., 112.],\n", + " [ 21., 19., 112., 114.],\n", + " [ 21., 19., 114., 116.],\n", + " [ 21., 19., 116., 118.],\n", + " [ 21., 19., 118., 120.],\n", + " [ 21., 19., 120., 122.],\n", + " [ 21., 19., 122., 124.],\n", + " [ 21., 19., 124., 126.],\n", + " [ 23., 21., 100., 102.],\n", + " [ 23., 21., 102., 104.],\n", + " [ 23., 21., 104., 106.],\n", + " [ 23., 21., 106., 108.],\n", + " [ 23., 21., 108., 110.],\n", + " [ 23., 21., 110., 112.],\n", + " [ 23., 21., 112., 114.],\n", + " [ 23., 21., 114., 116.],\n", + " [ 23., 21., 116., 118.],\n", + " [ 23., 21., 118., 120.],\n", + " [ 23., 21., 120., 122.],\n", + " [ 23., 21., 122., 124.],\n", + " [ 23., 21., 124., 126.],\n", + " [ 25., 23., 100., 102.],\n", + " [ 25., 23., 102., 104.],\n", + " [ 25., 23., 104., 106.],\n", + " [ 25., 23., 106., 108.],\n", + " [ 25., 23., 108., 110.],\n", + " [ 25., 23., 110., 112.],\n", + " [ 25., 23., 112., 114.],\n", + " [ 25., 23., 114., 116.],\n", + " [ 25., 23., 116., 118.],\n", + " [ 25., 23., 118., 120.],\n", + " [ 25., 23., 120., 122.],\n", + " [ 25., 23., 122., 124.],\n", + " [ 25., 23., 124., 126.]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 创建一个 65 * 4 的矩阵, 每个单元格对应划分的网格, 单元格内有四个值, 分别对应网格的上下左右边界值\n", + "\n", + "grid_margin = np.zeros((13*5, 4))\n", + "\n", + "margin_top = np.repeat(range(17, 26, 2), 13)\n", + "margin_bottom = np.repeat(range(15, 24, 2), 13)\n", + "margin_left = np.tile(range(100, 125, 2), 5)\n", + "margin_right = np.tile(range(102, 127, 2), 5)\n", + "\n", + "grid_margin[:, 0] = margin_top\n", + "grid_margin[:, 1] = margin_bottom\n", + "grid_margin[:, 2] = margin_left\n", + "grid_margin[:, 3] = margin_right\n", + "\n", + "grid_margin" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 创建一个 20 x 8 大小的画布\n", + "fig = plt.figure(figsize=(20, 8))\n", + "\n", + "# 将画布划分成 5 行 13 列的网格子区域， 并获取每个子区域的Axes对象\n", + "axes = []\n", + "for row in range(4, -1, -1):\n", + " for col in range(13):\n", + " ax = fig.add_subplot(5, 13, row * 13 + col + 1, aspect='equal')\n", + " ax.set_xticks([]) # 清空x轴的刻度值\n", + " ax.set_yticks([]) # 清空y轴的刻度值\n", + " ax.set_title((col+1) + 13*(4 - row) , fontsize=20, y=0.3)\n", + " axes.append(ax)\n", + "\n", + "# 对每个子区域的Axes对象进行设置和绘图\n", + "for i, ax in enumerate(axes):\n", + " ax.text(0.5, 0.95, int(grid_margin[i][0]), ha='center', va='top', fontsize=12, transform=ax.transAxes)\n", + " ax.text(0.5, 0.05, int(grid_margin[i][1]), ha='center', va='bottom', fontsize=12, transform=ax.transAxes)\n", + " ax.text(0.05, 0.5, int(grid_margin[i][2]), ha='left', va='center', fontsize=12, rotation=90, transform=ax.transAxes)\n", + " ax.text(0.95, 0.5, int(grid_margin[i][3]), ha='right', va='center', fontsize=12, rotation=-90, transform=ax.transAxes)\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/old-note-py-pyData/Matplotlib/matplotlib.pyplot.ipynb b/python/old-note-py-pyData/Matplotlib/matplotlib.pyplot.ipynb new file mode 100644 index 0000000..12eb8eb --- /dev/null +++ b/python/old-note-py-pyData/Matplotlib/matplotlib.pyplot.ipynb @@ -0,0 +1,108 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 相关配置" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`plt.rcParams['axes.unicode_minus'] = False` 指示 Matplotlib 不要使用 Unicode 渲染负号，而是使用正常的 ASCII 字符进行渲染, 从而解决负号显示异常的问题\n", + "\n", + "`plt.rcParams['font.family'] = ['Microsoft YaHei']` 解决中文乱码问题\n", + "\n", + "'SimHei' 无法显示负号, 'Arial' 无法显示中文, 两个一起就可以互补\n", + "`plt.rcParams['font.family'] = ['Arial', 'SimHei']`\n", + "\n", + "`plt.rcParams['font.sans-serif']` 配置的是无衬线字体, 当 Matplotlib 需要用到无衬线字体时, 会优先从这里去寻找对应的字体。\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Axes (ax)\n", + "\n", + "Axes 对象是一个二维坐标系，用于绘制数据图形。\n", + "\n", + "plt.subplots() 方法创建一个 Figure 和一个或多个 Axes 对象。Figure 对象是一个画布，它可以包含多个子图（即 Axes 对象），而每个 Axes 对象则代表画布上的一个绘图区域，可用于绘制线条、散点图、柱状图等各种图形。\n", + "\n", + "在 Pandas 绘图时，使用 df.plot() 方法会返回一个 AxesSubplot 对象，该对象实际上是 Axes 对象的一种类型，可用于进一步修改和定制绘图样式。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 `plt.xticks()` 设置坐标轴刻度的位置和标签。\n", + "\n", + "有以下参数:\n", + "- `ticks` 指定刻度位置的列表或数组。\n", + "- `labels`: 指定刻度标签的列表或数组。\n", + "\n", + "- `fontdict`: 字体属性, 它是字典对象，用于指定文本的字体属性, 比如\n", + " - `'family'`: 字体名称或字体族名称。\n", + " - `'style'` 或 `'fontstyle'`: 字体风格，取值范围为 {normal, italic, oblique}。\n", + " - `'variant'` 或 `'fontvariant'`: 字体变体，取值范围为 {normal, small-caps}。\n", + " - `'weight'` 或 `'fontweight'`: 字体粗细，取值范围为 {normal, bold, bolder, lighter, 100-900}。\n", + " - `'size'` 或 `'fontsize'`: 字体大小，以磅为单位，默认为 12。\n", + " - `'color'`: 文本颜色，可以使用 RGB 元组、HTML 颜色字符串、CSS 颜色名等表示方式。\n", + "\n", + "- `withdash`: 是否在 tick 上画虚线，默认为 False。\n", + "\n", + "- `rotation` 控制标签的旋转角度。 有以下值:\n", + " - `0` or `horizontal`: 水平\n", + " - `90` or `'vertical'`: 垂直\n", + " - positive/negative integer, 比如 `45` 和 `-45`\n", + "\n", + "- `alpha`: 设置刻度标签的透明度，取值范围为 [0, 1]。\n", + "\n", + "- `minor`: 布尔型变量，是否显示次要刻度，默认为 False。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 `plt.text()` 添加文本并定义相关属性\n", + "\n", + "它的语法如下：\n", + "\n", + "```py\n", + "plt.text(x, y, s, fontdict=None, withdash=False, **kwargs)\n", + "```\n", + "其中：\n", + "\n", + "- `x` 和 `y` 是文本放置的位置坐标。\n", + "- `s` 是要显示的文本内容。\n", + "- `fontdict` 是一个字典，用于设置文本样式，包括字体大小、颜色、字体名称等等。例如，`{'size': 16, 'color': 'red', 'family': 'serif'}`。\n", + "- `withdash` 如果为 True，则将文本化为带破折号的文本。\n", + "- `**kwargs` 其他的参数，比如旋转角度、文本对齐方式等等。\n", + " - `rotation`: 旋转角度。\n", + " - `ha`: 表示文本的水平对齐方式。 `ha='center'` 表示文本水平居中显示。\n", + " - `va`：表示文本的垂直对齐方式，例如 top、bottom 或者 center。\n", + " - `color`：表示文本的颜色。\n", + " - `bbox`：表示一个字典，用于设置文本的背景框，包括颜色和透明度等等。例如，{'facecolor': 'yellow', 'alpha': 0.5}。\n", + " - `fontweight`：表示文本的粗细程度，例如 normal、bold 或者 light。\n", + " - `fontstyle`：表示文本的风格，例如 normal、italic 或者 oblique。" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/old-note-py-pyData/NumPy/numpy.ipynb b/python/old-note-py-pyData/NumPy/numpy.ipynb new file mode 100644 index 0000000..9774e2d --- /dev/null +++ b/python/old-note-py-pyData/NumPy/numpy.ipynb @@ -0,0 +1,78 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> 在正态分布中，大约68%的值落在均值加减一个标准差的范围内，大约95%的值落在均值加减两个标准差的范围内，大约99.7%的值落在均值加减三个标准差的范围内。但需要注意的是，由于正态分布是连续分布，因此实际上可以生成任何实数值。\n", + "\n", + "🌰\n", + "下面这段代码能生成100个符合正态分布的均值为150, 标准差为10的随机整数\n", + "```py\n", + "import numpy as np\n", + "numbers = np.round(np.random.normal(150, 10, size=100)).astype(int)\n", + "```\n", + "- `np.random.normal(150, 10, size=100)` 借用 `numpy` 库中的 `random.normal()` 函数生成100个均值为150, 标准差为10的正态分布随机数\n", + "- `np.round()` 函数能将浮点数四舍五入为整数, 此时数据类型还是浮点数\n", + "- `astype(int)` 函数能将数据类型转换为整数类型。 具体地说, 是将 `numpy.ndarray` 的元素的数据类型转换为 `numpy.int32` 整型" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 `numpy.linspace()` 在指定的间隔内返回均匀间隔的数字\n", + "\n", + "`numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)` 是在指定的间隔内返回均匀间隔的数字。\n", + "\n", + "这个函数的参数如下: \n", + "- `start`: 序列的起始值\n", + "- `stop`: 序列的结束值，如果endpoint=True，则该值包括在序列中\n", + "- `num`: 要生成的等间隔样例数量，默认为50\n", + "- `endpoint`: 序列中是否包含stop值，默认为True\n", + "- `retstep`: 如果为True，则返回样例之间的步长\n", + "- `dtype`: 数组的类型。默认是None\n", + "- `axis`: 生成的数组中的轴\n", + "返回一个一维数组，按照指定的间隔均匀分布，例如: \n", + "```py\n", + "# 生成一个长度为5的一维数组，其中包含0到10之间的5个等间隔样例。\n", + "bins = np.linspace(0, 10, num=5)\n", + "bins # array([ 0. , 2.5, 5. , 7.5, 10. ])\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 `np.cumsum()` 计算数组元素的累积和。\n", + "\n", + "`np.cumsum()` 函数，需要提供一个数组作为输入参数。该函数将返回一个与输入数组具有相同形状的数组，其中每个元素都是原始数组对应位置之前所有元素的累加值。\n", + "\n", + "```py\n", + "import numpy\n", + "numpy.cumsum(a, axis=None, dtype=None, out=None)\n", + "```\n", + "参数说明: \n", + "\n", + "- `a`: 输入数组。\n", + "- `axis`: 指定在哪个轴上计算累计和。默认情况下，将所有元素相加。\n", + "- `dtype`: 输出数组的数据类型。如果此参数未给出，则返回类型由输入数据类型推断得出。\n", + "- `out`: 输出结果的数组。它必须与输入数组具有相同的形状。\n", + "\n", + "返回输入数组的累计和。" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/old-note-py-pyData/Pandas/pandas.ipynb b/python/old-note-py-pyData/Pandas/pandas.ipynb new file mode 100644 index 0000000..0a538f4 --- /dev/null +++ b/python/old-note-py-pyData/Pandas/pandas.ipynb @@ -0,0 +1,575 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`pandas` 读取 CSV 文件, 通常返回 `DataFrame`(二维) 对象或 `Series`(一维) 对象\n", + "\n", + "```py\n", + "df = pd.read_csv('your_file.csv')\n", + "```\n", + "\n", + "返回一个 `DataFrame` 对象, 该对象常见属性有\n", + "- `values` 数据的二维数组。 数据不包含列名\n", + "- `columns` 所有列名/列标签\n", + "- `index` 行标签 / 索引 的信息。 因为索引通常是连续的数字, 所以只给出信息, 想要查看具体值可调用其 `tolist()`\n", + "- `shape` 包含 (行数, 列数) 的元组\n", + "- `dtypes` 包含每列数据类型的 `Series` 对象\n", + "- `empty` 返回 `True` or `False`\n", + "- `T` 返回转置后的 df, 即行列互换\n", + "\n", + "常见的方法有:\n", + "- `mean()` 返回 `Series` 对象, 值为每列的均值, 索引为 DataFrame 的列名\n", + "- `transpose()` 返回转置后的 df, 即行列互换\n", + "- `sample()` 随机获取数据集中的一部分样本, \n", + " - `frac` 参数指定了需要保留的样本比例\n", + " - `n` 参数指定了需要保留的样本数量\n", + " - `random_state` 随机种子" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 `pd.DataFrame()` 用于创建 pandas 的数据结构 `DataFrame`（数据帧）\n", + "\n", + "DataFrame 是一个二维表格，可容纳不同类型的数据，并提供了各种方法来处理数据。\n", + "\n", + "函数语法如下: \n", + "```py\n", + "pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)\n", + "```\n", + "其中参数含义为: \n", + "- `data`: 数据输入，可以是各种形式，例如 ndarray、series、map、lists、dict 等等。\n", + "- `index`: 索引即行标签，长度必须和数据的行数相等，如果不指定，默认从 0 开始递增。\n", + "- `columns`: 数据列的名称，长度必须和数据的列数相等，如果不指定，默认从 0 开始递增。\n", + "- `dtype`: 指定数据类型，如果不指定，将自动推断数据类型。\n", + "- `copy`: 默认为 False，表示对原数据进行引用，如果为 True，则表示复制一份数据。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 loc 和 iloc\n", + "\n", + "`loc`: location. 通过标签来提取对应列。\n", + "\n", + "`iloc`: integer location, 通过整数索引(行号,列号)来提取对应行列\n", + "\n", + "他们都接收两个参数, 第一个参数用于指定行, 第二个参数用于指定列\n", + "\n", + "直接通过 `[columns]` 方式, 是相当于 `loc[:, columns]`, 即直接索引时, `columns` 会被认为是列名\n", + "\n", + "如果同时使用数字和字符串进行定位, 请使用 `loc` 而不是 `iloc`。\n", + "\n", + "`loc` 和 `iloc` 都可以使用数字, 他们的区别在于, `loc` 中的\"数字\"是标签, 即索引值, 而 `iloc` 中的数字是行号,列号。具体请见下面这个例子:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0\n", + "9 9\n", + "0 0\n", + "6 6\n", + " 0\n", + "1 1\n", + "2 2\n", + "3 3\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# 将数组转换为数据框架\n", + "df = pd.DataFrame([i for i in range(10)]).sample(frac=1)\n", + "print(df.iloc[[1,2,3], :]) # 取前三行, 此时前三行的索引不一定是 1,2,3\n", + "print(df.loc[[1,2,3], :]) # 取三行, 指定他们的索引为 1,2,3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 `pd.cut()` 将一组数据分成多个离散的区间(bin)\n", + "\n", + "pandas 中的 `pd.cut()` 函数是用于将一组数据分成多个离散的区间（bin）的函数。它的作用类似于直方图，可以将连续变量离散化为多个区间，并且在每个区间内统计变量的频数。\n", + "\n", + "pd.cut() 的语法如下: \n", + "\n", + "```py\n", + "pd.cut(x, bins, right=True, labels=None, retbins=False, precision=3, \n", + " include_lowest=False, duplicates='raise', rdered=True)\n", + "```\n", + "其中，主要参数包括: \n", + "\n", + "- `x`: 要离散化的数据，必选参数。\n", + "- `bins`: 指定划分区间的方式，可传入整数（表示将数据平均分成几个区间）、序列（表示每个区间的范围）或者 Pandas intervalIndex 对象。默认值为 `None`，表示让算法自动选择合适的区间。\n", + "- `right`: 是否将右端点设为闭区间。默认为 True，即所有区间都是左开右闭。\n", + "- `labels`: 指定离散化后每个区间的标签，可以传入一个列表或数组。\n", + "- `retbins`: 是否返回被使用的区间，如果设置为 True，则返回一个元组，第一个元素为离散化后的结果，第二个元素为被使用的区间。\n", + "- `precision`: 指定区间的精度，默认为 3，表示小数点后三位。\n", + "- `include_lowest`: 是否包含最小值所在的区间，默认为 False，即不包含。\n", + "- `duplicates`: 当指定的区间出现重叠时的处理方式，可选参数为 `'raise'`、`'drop'` 和 `'raise'`. 默认值为 `'raise'`.\n", + "\n", + "`pd.cut()` 函数默认返回的是 `pandas.Categorical` 类型的对象，它表示每个元素属于哪个区间。Categorical 对象有很多方便的方法，例如 `value_counts()` 可以统计各个区间中的元素个数。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 Series 常见统计函数" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- `count()`：返回非缺失值元素的数量。\n", + "- `sum()`：返回所有元素的和。\n", + "- `mean()`：返回所有元素的平均值。\n", + "- `median()`：返回所有元素的中位数。\n", + "- `min()`：返回所有元素的最小值。\n", + "- `max()`：返回所有元素的最大值。\n", + "- `quantile(q)`：返回所有元素的第 q 分位数（0 ≤ q ≤ 1）。\n", + "- `var()`：返回所有元素的方差。\n", + "- `std()`：返回所有元素的标准差。\n", + "- `mad()`：返回所有元素的平均绝对偏差。\n", + "- `skew()`：返回所有元素的偏度。\n", + "- `kurtosis()`：返回所有元素的峰度。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- `value_counts()`：统计各个元素出现的次数\n", + "- `unique()`：返回 Series 中不同元素的值，以 NumPy 数组形式返回。\n", + "- `nunique()`：返回 Series 中不同元素的数量。\n", + "- `idxmin()` 和 `idxmax()`：返回 Series 最小（最大）值的索引标签。\n", + "- `mean()` 和 `median()`：分别返回 Series 的均值和中位数。\n", + "- `min()` 和 `max()`：返回 Series 的最小和最大值。\n", + "- `describe()`：返回 Series 基本的描述统计信息，包括 count、mean、std、min、25%、50%、75%、max 等。\n", + "- `cumsum()` 和 `cumprod()`：分别返回 Series 中元素累积求和和累积求积的结果。\n", + "- `sample()`：从 Series 中随机抽取指定数量的元素。\n", + "- `apply()`：对每个元素应用自定义函数，返回一个新的 Series。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 案例" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 使用 `loc` 快捷替换指定行指定列的内容" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " c score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 1 10.9 10.9 10.9 10.93 10.93 1\n", + " c score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 1 9.0 9.0 9.0 93.0 93.0 1\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# 创建一个DataFrame\n", + "df = pd.DataFrame({\n", + " 'c': [1],\n", + " 'score-1': [10.9],\n", + " 'score-2': [10.9],\n", + " 'score-3': [10.9],\n", + " 'score-4': [10.93],\n", + " 'score-5': [10.93],\n", + " 'Mean recall scores': [1]\n", + "})\n", + "\n", + "print(df)\n", + "\n", + "\n", + "# 要替换的行和列\n", + "index = 0\n", + "columns = [f'score-{i+1}' for i in range(5)]\n", + "\n", + "# 要替换成的新值\n", + "scores = [9, 9, 9, 93, 93]\n", + "data = {'score-' + str(i+1): scores[i] for i in range(len(scores))}\n", + "new_row = pd.Series(data)\n", + "\n", + "# 使用 loc 函数进行替换\n", + "df.loc[index, columns] = new_row\n", + "\n", + "\n", + "print(df)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 使用 `concat` 新增行数据" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 1 0 4 0 10 5 1\n", + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 1 0 4 0 10 5 1\n", + "0 NaN 3 4 8 3 2 NaN\n", + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 1 0 4 0 10 5 1\n", + "0 NaN 3 4 8 3 2 NaN\n", + "1 2 NaN NaN NaN NaN NaN 2\n", + " C_parameter score-1 score-2 score-3 score-4 score-5 Mean recall scores\n", + "0 1 0 4 0 10 5 1\n", + "1 NaN 3 4 8 3 2 NaN\n", + "2 2 NaN NaN NaN NaN NaN 2\n", + "3 NaN 5 10 0 1 7 NaN\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import random as rd\n", + "\n", + "# 创建一个包含数值的数组\n", + "scores = [rd.randint(0,10) for i in range(len(scores))]\n", + "# 使用字典推导式创建字典\n", + "data = {'score-' + str(i+1): scores[i] for i in range(len(scores))}\n", + "row = pd.Series(data)\n", + "\n", + "K = 5\n", + "o = ['C_parameter', 'Mean recall scores']\n", + "n = [f'score-{i}' for i in range(1, K+1)]\n", + "columns = o[:1] + n + o[1:]\n", + "df = pd.DataFrame(columns=columns)\n", + "\n", + "# row.to_frame() 将 Series 转换为一个 DataFrame 对象\n", + "df = pd.concat([df, row.to_frame().T], ignore_index=True)\n", + "df.loc[0, 'C_parameter'] = 1\n", + "df.loc[0, 'Mean recall scores'] = 1\n", + "\n", + "print(df)\n", + "\n", + "scores = [rd.randint(0,10) for i in range(len(scores))]\n", + "data = {'score-' + str(i+1): scores[i] for i in range(len(scores))}\n", + "row = pd.Series(data)\n", + "df = pd.concat([df, row.to_frame().T], ignore_index=False)\n", + "\n", + "print(df)\n", + "\n", + "df.loc[1, 'C_parameter'] = 2\n", + "df.loc[1, 'Mean recall scores'] = 2\n", + "\n", + "print(df)\n", + "\n", + "scores = [rd.randint(0,10) for i in range(len(scores))]\n", + "data = {'score-' + str(i+1): scores[i] for i in range(len(scores))}\n", + "row = pd.Series(data)\n", + "df = pd.concat([df, row.to_frame().T], ignore_index=True)\n", + "\n", + "print(df)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 获取 A 列的最大值所在行 B 列的值" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " A B C D E\n", + "0 0.374540 0.950714 0.731994 0.598658 0.156019\n", + "1 0.155995 0.058084 0.866176 0.601115 0.708073\n", + "2 0.020584 0.969910 0.832443 0.212339 0.181825\n", + "3 0.183405 0.304242 0.524756 0.431945 0.291229\n", + "4 0.611853 0.139494 0.292145 0.366362 0.456070\n", + "\n", + "4\n", + "0.13949386065204183\n", + "\n", + "0.8661761457749352\n", + " A B C D E\n", + "1 0.155995 0.058084 0.866176 0.601115 0.708073\n", + "0.6011150117432088\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# 随机生成 5x5 数组\n", + "np.random.seed(42)\n", + "data = np.random.rand(5, 5)\n", + "\n", + "# 将数组转换为数据框架\n", + "df = pd.DataFrame(data, columns=['A', 'B', 'C', 'D', 'E'])\n", + "\n", + "# 显示数据框架\n", + "print(df)\n", + "print('')\n", + "\n", + "# 方法1\n", + "i_max = df['A'].idxmax()\n", + "print(i_max)\n", + "maxA_B = df.loc[i_max, 'B']\n", + "print(maxA_B)\n", + "print('')\n", + "\n", + "# 方法2\n", + "maxC = df['C'].max()\n", + "print(maxC)\n", + "row_with_max_c = df.loc[df['C'] == maxC]\n", + "print(row_with_max_c)\n", + "maxC_D = row_with_max_c.iloc[0]['D']\n", + "print(maxC_D)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## pd.cut 案例" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " A category\n", + "0 46 (40, 60]\n", + "1 61 (60, 80]\n", + "2 50 (40, 60]\n", + "3 54 (40, 60]\n", + "4 63 (60, 80]\n", + "5 2 (0, 20]\n", + "6 50 (40, 60]\n", + "7 6 (0, 20]\n", + "8 20 (0, 20]\n", + "9 72 (60, 80]\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# 随机生成一些数据\n", + "df = pd.DataFrame({\"A\": np.random.randint(0, 100, 10)})\n", + "\n", + "# 定义区间范围\n", + "bins = [0, 20, 40, 60, 80, 100]\n", + "\n", + "# 使用 pd.cut 进行区间划分\n", + "df[\"category\"] = pd.cut(df[\"A\"], bins)\n", + "\n", + "# 打印结果\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " A category\n", + "0 66 正数+\n", + "1 -83 负数-\n", + "2 31 正数+\n", + "3 -12 负数-\n", + "4 -41 负数-\n", + "5 -87 负数-\n", + "6 -92 负数-\n", + "7 -11 负数-\n", + "8 -48 负数-\n", + "9 29 正数+\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# 随机生成一些数据\n", + "df = pd.DataFrame({\"A\": np.random.randint(-100, 100, 10)})\n", + "\n", + "# 定义区间范围\n", + "bins = [-100, 0, 100]\n", + "labels = ['负数-', '正数+']\n", + "\n", + "# 使用 pd.cut 进行区间划分\n", + "df[\"category\"] = pd.cut(df[\"A\"], bins=bins, labels=labels)\n", + "\n", + "# 打印结果\n", + "print(df)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "将一个 DataFrame 中的 'LAT' 列中的数据按照一定范围分为不同的区间，并为每个区间分配一个标签。" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " LAT LAT_zone\n", + "0 40.7128 warm temperate\n", + "1 37.7749 warm temperate\n", + "2 51.5074 warm temperate\n", + "3 35.6895 warm temperate\n", + "4 52.5200 warm temperate\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# 构造示例 DataFrame\n", + "df = pd.DataFrame({'LAT': [40.7128, 37.7749, 51.5074, 35.6895, 52.5200]})\n", + "\n", + "# 定义分割点和标签\n", + "bins = [-90, -60, -30, 0, 30, 60, 90]\n", + "labels = ['south pole', 'subpolar', 'temperate', 'subtropical', 'warm temperate', 'tropic']\n", + "\n", + "# 使用 pd.cut 进行分段，并为每个区间分配相应的标签\n", + "df['LAT_zone'] = pd.cut(df['LAT'], bins=bins, labels=labels)\n", + "\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " LAT LAT_zone\n", + "0 -22.582779 temperate\n", + "1 81.128575 tropic\n", + "2 41.758910 warm temperate\n", + "3 17.758527 subtropical\n", + "4 -61.916645 south pole\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# 生成随机经纬度数据\n", + "np.random.seed(42)\n", + "n = 1000 # 数据量设定为1000\n", + "LAT = np.random.uniform(low=-90, high=90, size=n)\n", + "df = pd.DataFrame({'LAT': LAT})\n", + "\n", + "# 定义分割点和标签\n", + "bins_LAT = [-90, -60, -30, 0, 30, 60, 90]\n", + "labels_LAT = ['south pole', 'subpolar', 'temperate', 'subtropical', 'warm temperate', 'tropic']\n", + "\n", + "\n", + "# 使用 pd.cut 进行分段，并为每个区间分配相应的标签\n", + "df['LAT_zone'] = pd.cut(df['LAT'], bins=bins_LAT, labels=labels_LAT)\n", + "\n", + "print(df.head())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/python basics/familiar data.ipynb b/python/python basics/familiar data.ipynb new file mode 100644 index 0000000..7e7894d --- /dev/null +++ b/python/python basics/familiar data.ipynb @@ -0,0 +1,150 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 推导式 (比循环快)\n", + "\n", + "- 列表推导式：`[expression for item in iterable if condition]`\n", + "- 集合推导式：`{expression for item in iterable if condition}`\n", + "- 字典推导式：`{key_expression: value_expression for item in iterable if condition}`\n", + "\n", + "其中，\n", + "- `expression` 表示要对 item 进行计算得到的结果，可以包含任意复杂的表达式；\n", + "- `item` 表示在 iterable 中的每个元素；\n", + "- `iterable` 表示一个可迭代对象，例如列表或者范围；\n", + "- `if condition` 是一个可选的条件表达式，用于过滤出符合条件的元素。" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "使用循环生成新列表的时间： 0.04245185852050781\n", + "使用列表推导式生成新列表的时间： 0.01600337028503418\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "# 使用循环生成新列表\n", + "a, b = [1, 2, 3, 4, 5] * 99999, []\n", + "start_time = time.time()\n", + "for i in a: b.append(i + 1)\n", + "print(\"使用循环生成新列表的时间：\", time.time() - start_time)\n", + "\n", + "# 使用列表推导式生成新列表\n", + "a = [1, 2, 3, 4, 5] * 99999\n", + "start_time = time.time()\n", + "b = [i + 1 for i in a]\n", + "print(\"使用列表推导式生成新列表的时间：\", time.time() - start_time)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['item ^ 2 = 9', 'item ^ 2 = 16', 'item ^ 2 = 25', 'item ^ 2 = 36', 'item ^ 2 = 49']\n", + "{'item ^ 2 = 25', 'item ^ 2 = 36', 'item ^ 2 = 49', 'item ^ 2 = 9', 'item ^ 2 = 16'}\n", + "{'3 ^ 2 = ': 9, '4 ^ 2 = ': 16, '5 ^ 2 = ': 25, '6 ^ 2 = ': 36, '7 ^ 2 = ': 49}\n" + ] + } + ], + "source": [ + "n = 7\n", + "arr = [f'item ^ 2 = {i * i}' for i in range(1, n+1) if i > 2]\n", + "print(arr)\n", + "arr = {f'item ^ 2 = {i * i}' for i in range(1, n+1) if i > 2}\n", + "print(arr)\n", + "arr = {f'{i} ^ 2 = ': i*i for i in range(1, n+1) if i > 2}\n", + "print(arr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 三元表达式\n", + "\n", + "```py\n", + "value_if_true if condition else value_if_false\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "❌\n" + ] + } + ], + "source": [ + "succeed = False\n", + "print('✔️' if succeed else '❌')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 空语句\n", + "\n", + "```py\n", + "pass\n", + "```\n", + "\n", + "注意⚠️，空语句并不是一个好的编程实践" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "if True:\n", + " pass" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/python basics/more pythonic.ipynb b/python/python basics/more pythonic.ipynb new file mode 100644 index 0000000..b6bec73 --- /dev/null +++ b/python/python basics/more pythonic.ipynb @@ -0,0 +1,951 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 划分数据" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "data = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]])\n", + "labels = np.array([0, 0, 1, 1, 1])\n", + "\n", + "train_data, test_data = np.split(data, [int(0.8 * len(data))])\n", + "train_labels, test_labels = np.split(labels, [int(0.8 * len(labels))])\n", + "print(train_data, test_data)\n", + "print(train_labels, test_labels)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 数值的区间映射/离散化" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "110.7\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "bins = [15, 16, 22, 25]\n", + "labels = [110.6, 110.7, 110.8]\n", + "\n", + "x = 18\n", + "y = labels[np.digitize(x, bins) -1]\n", + "\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "110.7\n" + ] + } + ], + "source": [ + "import bisect\n", + "\n", + "bins = [15, 16, 22, 25]\n", + "labels = [110.6, 110.7, 110.8]\n", + "\n", + "x = 18\n", + "y = labels[bisect.bisect_left(bins, x) -1]\n", + "\n", + "print(y)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 set 合并" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = set([1, 2])\n", + "b = set([3, 4])\n", + "c = set([5])\n", + "a = list(a)\n", + "b = list(b)\n", + "c = list(c)\n", + "set(a+b+c)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = set([1, 2])\n", + "b = set([3, 4])\n", + "c = set([5])\n", + "set(a).union(set(b), set(c))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = set([1, 2])\n", + "b = set([3, 4])\n", + "c = set([5])\n", + "set().union(*[a, b, c])" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = set([1, 2])\n", + "b = set([3, 4])\n", + "c = set([5])\n", + "result_set = set()\n", + "result_set.update(a)\n", + "result_set.update(b)\n", + "result_set.update(c)\n", + "result_set" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = set([1, 2])\n", + "b = set([3, 4])\n", + "c = set([5])\n", + "{x for s in [a, b, c] for x in s}" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = set([1, 2])\n", + "b = set([3, 4])\n", + "c = set([5])\n", + "set([*a, *b, *c])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import itertools\n", + "a = set([1, 2])\n", + "b = set([3, 4])\n", + "c = set([5])\n", + "set(itertools.chain(a, b, c))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 判断是否包含 x" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "a = set([1, 2, 3])\n", + "b = set([1])\n", + "a = list(a)\n", + "b = list(b)[0]\n", + "if b in a:\n", + " print('1')" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "a = set([1, 2, 3])\n", + "b = set([1])\n", + "\n", + "if set(a) & set(b):\n", + " print('1')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "a = set([1, 2, 3])\n", + "b = set([1])\n", + "\n", + "if set(b).issubset(set(a)):\n", + " print('1')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "a = set([1, 2, 3])\n", + "b = set([1])\n", + "\n", + "if all(elem in a for elem in b):\n", + " print('1')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 筛选 df" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. 借助 query 函数\n", + "\n", + "```py\n", + "TF_data = TF_ALL.query('15 <= LAT <= 25 and 100 <= LONG <= 126')\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. 链式操作\n", + "\n", + "```py\n", + "TF_data = TF_ALL[(TF_ALL['LAT'] <= 25) & (TF_ALL['LAT'] >= 15) & (TF_ALL['LONG'] <= 126) & (TF_ALL['LONG'] >= 100)]\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. 借助 between\n", + "\n", + "```py\n", + "TF_data = TF_ALL[TF_ALL['LAT'].between(15, 25) & TF_ALL['LONG'].between(100, 126)]\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4. 利用 loc \n", + "\n", + "```py\n", + "TF_data = TF_ALL.loc[(TF_ALL['LAT'] <= 25) & (TF_ALL['LAT'] >= 15) & (TF_ALL['LONG'] <= 126) & (TF_ALL['LONG'] >= 100)]\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5. \n", + "\n", + "```py\n", + "TF_data = TF_ALL\n", + "TF_data = TF_data[TF_data['LAT'] <= 25]\n", + "TF_data = TF_data[TF_data['LAT'] >= 15]\n", + "TF_data = TF_data[TF_data['LONG'] <= 126]\n", + "TF_data = TF_data[TF_data['LONG'] >= 100]\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 求差集" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. 使用列表推导式" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 4, 5, 7, 8, 9]\n" + ] + } + ], + "source": [ + "a = [2, 3, 6]\n", + "b = [i for i in range(1,10) if i not in a]\n", + "print(b)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. 使用 set 集合" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 4, 5, 7, 8, 9]\n" + ] + } + ], + "source": [ + "a = [2, 3, 6]\n", + "b = list(set(range(1,10)) - set(a))\n", + "print(b)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. 使用 lambda" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 4, 5, 7, 8, 9]\n" + ] + } + ], + "source": [ + "a = [2, 3, 6]\n", + "b = list(filter(lambda x: x not in a, range(1,10)))\n", + "print(b)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 df 分组, 然后赋值" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. 直接使用循环\n", + "\n", + "```py\n", + "for i in range(len(df)):\n", + " if df['LAT'][i] >= 5 and df['LAT'][i] < 16:\n", + " df.loc[i, 'beta'] = 110.6\n", + " elif df['LAT'][i] >= 16 and df['LAT'][i] < 22:\n", + " df.loc[i, 'beta'] = 110.7\n", + " elif df['LAT'][i] >= 22 and df['LAT'][i] < 29:\n", + " df.loc[i, 'beta'] = 110.8\n", + " else:\n", + " df.loc[i, 'beta'] = 110.5\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. 使用pandas的apply函数和lambda表达式\n", + "\n", + "```py\n", + "import pandas as pd\n", + "\n", + "def get_beta(lat):\n", + " if lat >= 5 and lat < 16:\n", + " return 110.6\n", + " elif lat >= 16 and lat < 22:\n", + " return 110.7\n", + " elif lat >= 22 and lat < 29:\n", + " return 110.8\n", + " else:\n", + " return 110.5\n", + "\n", + "df['beta'] = df['LAT'].apply(lambda x: get_beta(x))\n", + "```\n", + "我们定义了一个名为get_beta的函数，并利用lambda表达式将其应用到df['LAT']这一列上。get_beta函数负责计算每个值对应的beta值，并返回该值。然后，我们将结果赋给df['beta']这一列。由于apply函数会在整个列向量化处理，因此它比循环更快，更Pythonic。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. 使用 numpy\n", + "\n", + "```py\n", + "import numpy as np\n", + "\n", + "lat = df['LAT'].values\n", + "beta = np.ones_like(lat) * 110.5\n", + "beta[(lat >= 5) & (lat < 16)] = 110.6\n", + "beta[(lat >= 16) & (lat < 22)] = 110.7\n", + "beta[(lat >= 22) & (lat < 29)] = 110.8\n", + "\n", + "df['beta'] = beta\n", + "```\n", + "我们首先将df['LAT']列转换为numpy数组。然后，我们创建一个与lat大小相同的全1数组，并将其乘以110.5作为初始值。接着，我们利用numpy的布尔索引和切片语法，根据不同条件分别为beta数组的相应位置赋值。最后，我们将结果赋给df['beta']列。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4. 使用pandas的cut函数\n", + "\n", + "```py\n", + "bins = [0, 5, 16, 22, 29, np.inf]\n", + "labels = [110.5, 110.6, 110.7, 110.8, 110.5]\n", + "df['beta'] = pd.cut(df['LAT'], bins=bins, labels=labels, ordered=False)\n", + "```\n", + "我们首先定义了一个离散化的区间bins和对应的标签labels。然后，我们使用pandas的cut函数，将df['LAT']列离散化并标记相应的标签。最后，我们将结果赋给df['beta']列。\n", + "\n", + "因为 labels 中出现了重复的值, 所以需要传递 ordered=False 来允许重复值。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 求 df 某列中值为 0 的数量" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. 利用 len 函数\n", + "\n", + "```py\n", + "len(df[df['a'] == 0])\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. 利用 sum 函数\n", + "\n", + "```py\n", + "(df['a'] == 0).sum()\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. 利用 value_counts 函数\n", + "\n", + "```py\n", + "counts = model_data['gridID'].value_counts()\n", + "counts.loc[counts.index == 0].sum()\n", + "```\n", + "\n", + "注意使用的是 `loc` 而不是 `[]`, 因为是基于 **索引标签** 进行定位, 而不是基于位置" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 🍕 对有缺失值的 series 进行填充" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. 利用 series 的 reindex 函数" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 1\n", + "3 1\n", + "dtype: int64\n", + "0 0\n", + "1 1\n", + "2 0\n", + "3 1\n", + "4 0\n", + "5 0\n", + "dtype: int64\n", + "[0, 1, 0, 1, 0, 0]\n" + ] + } + ], + "source": [ + "# 创建Series对象\n", + "s = pd.Series([1, 3]).value_counts()\n", + "print(s)\n", + "\n", + "# 按索引对Series对象进行重排，并将空值填充为0\n", + "s = s.reindex(range(0,6), fill_value=0)\n", + "print(s)\n", + "\n", + "# 将Series对象转换为列表并赋值给数组\n", + "arr = s.tolist()\n", + "\n", + "print(arr)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. 直接赋值" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 1. 0. 3. 0.]\n" + ] + } + ], + "source": [ + "s = pd.Series([1, 3], index=[1, 3])\n", + "\n", + "# 创建全零数组，长度为5\n", + "arr = np.zeros(5)\n", + "\n", + "# 将Series对象赋值给数组对应索引位置\n", + "arr[s.index] = s.values\n", + "\n", + "print(arr)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. 利用 df 作为中间处理值" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 0, 3, 0, 0]\n" + ] + } + ], + "source": [ + "# 创建Series对象\n", + "s = pd.Series([1, 3], index=[1, 3])\n", + "\n", + "# 创建一个空的DataFrame\n", + "df = pd.DataFrame(columns=['col'], index=range(0,6))\n", + "\n", + "# 将Series对象赋值给DataFrame对应索引位置\n", + "df.loc[s.index, 'col'] = s.values\n", + "\n", + "# 将DataFrame转换为列表并赋值给数组\n", + "arr = df['col'].fillna(0).tolist()\n", + "\n", + "print(arr)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4. 利用字典" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1: 1, 3: 3}\n", + "{1: 1, 3: 3, 0: 0, 2: 0, 4: 0, 5: 0}\n", + "[0, 1, 0, 3, 0, 0]\n" + ] + } + ], + "source": [ + "# 创建Series对象\n", + "s = pd.Series([1, 3], index=[1, 3])\n", + "\n", + "# 将Series对象转换为字典，并且将所有没有对应索引位置的值置为0\n", + "d = s.to_dict()\n", + "print(d)\n", + "d.update({i: 0 for i in range(0, 6) if i not in d})\n", + "print(d)\n", + "\n", + "# 列表解析式，按索引位置填充值\n", + "arr = [d[i] for i in range(0, 6)]\n", + "\n", + "print(arr)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5. 利用列表解析式" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 0, 3, 0, 0]\n" + ] + } + ], + "source": [ + "# 创建Series对象\n", + "s = pd.Series([1, 3], index=[1, 3])\n", + "\n", + "# 列表解析式，按索引位置填充值\n", + "arr = [s[i] if i in s.index else 0 for i in range(0, 6)]\n", + "\n", + "print(arr)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6. 利用 put 函数" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 1. 0. 3. 0.]\n" + ] + } + ], + "source": [ + "# 创建Series对象\n", + "s = pd.Series([1, 3], index=[1, 3])\n", + "\n", + "# 创建全零数组，长度为5\n", + "arr = np.zeros(5)\n", + "\n", + "# 将Series对象赋值给数组对应索引位置\n", + "np.put(arr, list(s.index), s.values)\n", + "\n", + "print(arr)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 7. 最简单" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 0, 3, 0]\n" + ] + } + ], + "source": [ + "# 创建Series对象\n", + "s = pd.Series([1, 3], index=[1, 3])\n", + "\n", + "# 创建一个长度为5的数组\n", + "arr = [0] * 5\n", + "\n", + "# 将Series对象按索引依次填充到数组中\n", + "for i in s.index:\n", + " arr[i] = s[i]\n", + "\n", + "print(arr)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/python basics/pip.md b/python/python basics/pip.md new file mode 100644 index 0000000..7357854 --- /dev/null +++ b/python/python basics/pip.md @@ -0,0 +1,84 @@ +[pip 文档 v22.3](https://pip.pypa.io/en/stable/cli/) + +## 🍕 零碎 + +```powershell +python -m site #　查看 sys.path +pip --version +pip --help +pip list # 列出已安装的包 +pip install # 如果已安装, 可以显示出包所在位置 +pip uninstall # 不要通过删除文件夹的方式进行卸载, 因为那样卸载不干净 +pip show # 查看安装的包的相关信息 + +pip install [-i | --index-url] +# 使用指定下载源下载包 +# 默认的镜像是: https://pypi.org/simple +# 豆瓣: https://pypi.doubanio.com/simple/ +# 清华: https://pypi.tuna.tsinghua.edu.cn/simple + +pip install ==1.7 # 可通过 ==, >=, <=, >, < 来指定安装版本 + +``` + +## 🍕 pip + +```powershell +py -m pip [options] +# 后面的语句一律省略 py -m +``` + +### options + +- `--proxy ` + + 比如 `pip install --proxy "127.0.0.1:7890"` + +### Description + +pip offers `-v`, `--verbose` and `-q` `--quiet` to control the **console log** level. + +## 🍕 pip cache + +```powershell +pip cache dir # Show the cache directory + +pip cache info + +pip cache list [] [--format=[human, abspath]] +# List filenames of packages stored in the cache. + +pip cache remove +# Remove one or more package from the cache +# can be a glob expression or a package name. + +pip cache purge + +``` + +## 🍕 pip config + +```powershell +pip config [] list +# List the active configuration (or from the file specified) + +pip config [] [--editor ] edit +pip config [] get command.option +pip config [] set command.option value +pip config [] unset command.option +pip config [] debug +``` + +### 示例 + +```powershell +pip config set global.proxy "127.0.0.1:7890" # 配置代理, user.proxy 不生效,有问题 +``` + + +### Options + +- `--editor ` +- `--global` +- `--user` +- `--site` diff --git "a/python/python basics/py\347\211\271\345\256\232\350\257\255\346\263\225.ipynb" "b/python/python basics/py\347\211\271\345\256\232\350\257\255\346\263\225.ipynb" new file mode 100644 index 0000000..5f93fe4 --- /dev/null +++ "b/python/python basics/py\347\211\271\345\256\232\350\257\255\346\263\225.ipynb" @@ -0,0 +1,1017 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 最大值最小值" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "inf -inf\n" + ] + } + ], + "source": [ + "max_val = float('inf')\n", + "min_val = float('-inf')\n", + "print(max_val, min_val)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 位运算" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "# 左移 4 位\n", + "i = 0xFFFF\n", + "i = i << 4 & 0xFFFF\n", + "print(i == 0xFFF0)\n", + "\n", + "# 无符号右移 4 位（右移补 0 ）\n", + "i = 0xFFFF\n", + "i >>= 4\n", + "print(i == 0x0FFF)\n", + "\n", + "# 求反运算\n", + "i = 0xFF00\n", + "i = ~i & 0xFFFF\n", + "print(i == 0x00FF)\n", + "\n", + "# 右移补 1\n", + "i = 0x00F0\n", + "i = ~i & 0xFFFF\n", + "i >>= 4\n", + "i = ~i & 0xFFFF\n", + "print(i == 0xF00F)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 切片\n", + "\n", + "语法： `start:end:step`\n", + "- `start`：表示切片的起始位置（包含该位置的元素）。如果未指定，则默认为索引 0。\n", + "- `end`：表示切片的结束位置（不包含该位置的元素）。如果未指定，则默认为切片对象的长度。\n", + "- `step`：表示切片的步长，即每次迭代之间的间隔。如果未指定，则默认为 1。 指定为 `-1` 逆向遍历。" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 8, 7, 6, 5, 9, 10]\n" + ] + } + ], + "source": [ + "# 反转数组的第5到第8个元素\n", + "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "a[4:8] = a[4:8][::-1]\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 10, 9, 8, 7, 6, 5]\n" + ] + } + ], + "source": [ + "# 从下标 4 (包含本身) 开始反转\n", + "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "a[4:] = a[4:][::-1]\n", + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 内置常用函数" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "97\n", + "a\n" + ] + } + ], + "source": [ + "print(ord('a')) # 字符转 ASCII\n", + "print(chr(97)) # ASCII 转字符" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 对象的魔法方法\n", + "\n", + "在 Python 中，以双下划线（__）开头和结尾的特殊方法（也称为魔术方法或魔法方法）用于实现对象的特定行为，例如运算符重载、自定义对象的比较、容器类型操作等。这些特殊方法的名称具有特殊的含义，并且由 Python 解释器在特定情况下自动调用。\n", + "\n", + "常见的以双下划线开头和结尾的特殊方法有：\n", + "\n", + "- `__init__`: 初始化方法，在创建对象时调用，用于初始化对象的属性。\n", + "- `__str__`: 字符串表示方法，在使用print()函数或str()函数时调用，返回对象的字符串表示。\n", + "- `__repr__`: 用于获取对象的“官方”字符串表示，一般用于调试和开发目的。\n", + "- `__add__`: 定义加法运算，使用+符号时调用。\n", + "- `__sub__`: 定义减法运算，使用-符号时调用。\n", + "- `__mul__`: 定义乘法运算，使用*符号时调用。\n", + "- `__div__`: 定义除法运算，使用/符号时调用。\n", + "- `__lt__`: 定义小于运算，使用<符号时调用。\n", + "- `__le__`: 定义小于等于运算，使用<=符号时调用。\n", + "- `__gt__`: 定义大于运算，使用>符号时调用。\n", + "- `__ge__`: 定义大于等于运算，使用>=符号时调用。\n", + "- `__eq__`: 定义等于运算，使用==符号时调用。\n", + "- `__ne__`: 定义不等于运算，使用!=符号时调用。\n", + "- `__len__`: 定义获取对象长度，使用len()函数时调用。\n", + "- `__getitem__`: 定义获取元素，使用索引或切片时调用。\n", + "- `__setitem__`: 定义设置元素，使用索引或切片进行赋值时调用。\n", + "- `__delitem__`: 定义删除元素，使用del关键字时调用。\n", + "- `__iter__`: 定义迭代器，允许对象进行迭代。\n", + "- `__next__`: 定义迭代器的下一个元素，配合__iter__使用。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 运算符" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- `a /= b`: 这样会是小数\n", + "- `a //= b`: 这样会是整数, 等同于 `a = int(a/b)`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5 1\n" + ] + } + ], + "source": [ + "a = 3\n", + "b = 2\n", + "print(a / b, a//b)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 反转数组" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'321'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = '123'\n", + "a[::-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4, 3, 2, 1]\n", + "[1, 2, 3, 4]\n" + ] + } + ], + "source": [ + "a = [1,2,3,4]\n", + "print(a[::-1])\n", + "print(a)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 处理数组每一个元素" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```py \n", + "map(int, ...) \n", + "```\n", + "py 内置函数 `map()`，它接受一个函数和一个可迭代对象作为参数，将该函数应用于可迭代对象的每个元素，返回一个包含结果的迭代器。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 3 \n" + ] + } + ], + "source": [ + "a, b, c = map(int, ['1', '2', '3'])\n", + "print(a,b,c,type(a),type(b),type(c))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 指定排序规则" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[1, 3, 'A'], [2, 2, 'B'], [3, 1, 'C']]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 指定以第几个元素进行排序, 默认从小到大排序, 如果想要从大到小排序, 可以使用 0-\n", + "a = [ [1, 3, 'A'], [2, 2, 'B'], [3, 1, 'C'], ]\n", + "ordered_a = sorted(a, key=lambda x: 0-x[1])\n", + "ordered_a" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[3, 1, 'C'], [3, 2, 'B'], [1, 3, 'A']]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 可以利用比较器指定排序规则\n", + "from functools import cmp_to_key\n", + "\n", + "a = [\n", + " [1, 3, 'A'],\n", + " [3, 2, 'B'],\n", + " [3, 1, 'C'],\n", + "]\n", + "ordered_a = sorted(a, key=cmp_to_key(lambda a, b: a[1]-b[1]))\n", + "ordered_a" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 拼接数组元素" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1, 2, 3\n" + ] + } + ], + "source": [ + "# 只能拼接字符串数组\n", + "a = ['1', '2', '3']\n", + "print( ', '.join(a) )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1, 2, 3\n" + ] + } + ], + "source": [ + "# 非字符串可以使用推导式来拼接\n", + "a =[1,2,3]\n", + "print(', '.join(str(i) for i in a))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 异常处理\n", + "\n", + "抛出错误:\n", + "```py\n", + "raise Exception('抛开事实不谈,难道你就没有错吗?')\n", + "```\n", + "\n", + "捕获错误:\n", + "```py \n", + "try:\n", + " # 执行代码\n", + "except:\n", + " # 出现错误时执行\n", + "else:\n", + " # 没有错误时执行\n", + "finally:\n", + " # 始终执行\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "内置的异常类\n", + "\n", + "-`Exception`: 这是所有内置异常类的基类，可以用于捕获和处理任何类型的异常。\n", + "\n", + "-`TypeError`: 当操作或函数应用于不适当类型的对象时引发的异常。\n", + "\n", + "-`ValueError`: 当操作或函数应用于具有正确类型但具有无效值的对象时引发的异常。\n", + "\n", + "-`IndexError`: 当尝试访问列表、元组或其他序列中不存在的索引时引发的异常。\n", + "\n", + "-`KeyError`: 当尝试使用字典中不存在的键时引发的异常。\n", + "\n", + "-`FileNotFoundError`: 当尝试打开不存在的文件时引发的异常。\n", + "\n", + "-`IOError`: 当发生与输入/输出操作相关的错误时引发的异常。\n", + "\n", + "-`NameError`: 当尝试访问未定义的变量或函数时引发的异常。\n", + "\n", + "-`ZeroDivisionError`: 当除法或取模运算的第二个操作数为零时引发的异常。\n", + "\n", + "-`AttributeError`: 当尝试访问对象上不存在的属性或方法时引发的异常。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "Exception", + "evalue": "抛开事实不谈,难道你就没有错吗?", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mException\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\Public\\GithubCode\\学习新知识过程中的代码\\learn-py\\python basics\\py特定语法.ipynb Cell 3\u001b[0m in \u001b[0;36m1\n\u001b[1;32m----> 1\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mException\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39m抛开事实不谈,难道你就没有错吗?\u001b[39m\u001b[39m'\u001b[39m)\n", + "\u001b[1;31mException\u001b[0m: 抛开事实不谈,难道你就没有错吗?" + ] + } + ], + "source": [ + "raise Exception('抛开事实不谈,难道你就没有错吗?')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "捕获到自定义错误: 除数不能为零\n" + ] + } + ], + "source": [ + "class CustomError(Exception):\n", + " pass\n", + "\n", + "def divide(a, b):\n", + " if b == 0:\n", + " raise CustomError(\"除数不能为零\")\n", + " return a / b\n", + "\n", + "try:\n", + " result = divide(10, 0)\n", + "except CustomError as e:\n", + " print(\"捕获到自定义错误:\", str(e))\n", + "except Exception as e:\n", + " print('捕获到未知错误: ', str(e))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 关键字 `is`、 `not`、 `None`\n", + "\n", + "- py `is` 用来比较对象的内存地址, 而 `==` 比较的是值。 所以判断对象时, 要注意是判断值还是判断对象地址。\n", + "- py 中是没有 `!` 对布尔值取反, 而是使用 `not` 关键字\n", + "- 判断 `None`, 不要使用 `== None`, `!= None`, 要使用 `is None`, `is not None`, 原因:\n", + " - 准确性: 比较的值是对象时, 可能会出错。\n", + " - 性能: `==` 涉及到对象值, 而 `is` 直接判断内存地址, 不需要再去寻找值\n", + " - 习惯: 这易于理解, 而且符合Python社区的约定。\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "# 准确性例子:\n", + "class MyClass:\n", + " def __eq__(self, other):\n", + " return True\n", + "\n", + "my_obj = MyClass()\n", + "print(my_obj == None) # 输出: True。 因为 == 是值判断, 所以会执行 __eq__\n", + "print(my_obj is None) # 输出: False。 " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 创建指定长度 list(数组)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n" + ] + } + ], + "source": [ + "# 一个一个添加的方式\n", + "arr = []\n", + "# arr[0] ❌\n", + "print(len(arr))\n", + "arr.append(1) # ✔️\n", + "print(len(arr))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 一次性创建的方式, 同时每个元素值递增\n", + "arr = list(range(10))\n", + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 一次性创建的方式, 同时每个值为 0\n", + "arr = [0] * 100\n", + "len(arr)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 如果元素是对象, 则不能使用 * 号进行一次性创建, 这样创建的数组, 每个元素的对象地址都是相同的\n", + "# sets = [ set() ] * 5 ❌\n", + "sets = [ set() for _ in range(5) ] # ✔️" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 格式化数字和字符串\n", + "\n", + "主要有三种方式\n", + "- `%` 格式化\n", + "- `format()` 格式化\n", + "- `f'{:}'` 格式化\n", + "\n", + "`{:格式说明符}`, 格式说明符有:\n", + "- 对齐, 用 `<`, `^`, `>` 分别表示左对齐、居中对齐、右对齐。\n", + "- 宽度：表示输出的最小宽度，比如 `{:5}` 表示输出最少占五个字符的空间。\n", + "- 填充：用任意字符来填充输出的空位，比如 `{:0>8}` 表示用 0 来填充，使得输出最少占八个字符的空间。\n", + "- 精度：对于浮点数，可以使用 `{:.2f}` 这样的格式说明符，表示保留两位小数。 使用 `{:,}` 可以为数字添加逗号分割数\n", + "- 类型: 比如 `f` 就是浮点数, `%` 是百分数, `d` 是整数, `e` 是指数 " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "My name is Alice and I'm 25 years old.\n" + ] + } + ], + "source": [ + "name = \"Alice\"\n", + "age = 25\n", + "print(\"My name is %s and I'm %-4d years old.\" % (name, age))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of x is 987.65\n" + ] + } + ], + "source": [ + "x = 987.654\n", + "print(\"The value of x is {:.2f}\".format(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of x is 987.65\n" + ] + } + ], + "source": [ + "x = 987.654\n", + "print(f'The value of x is {x:.2f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I am ___25.00 years old, and my name is Alice-----. | 12,345,678 | 2% | 1.235e+07\n" + ] + } + ], + "source": [ + "name = \"Alice\"\n", + "age = 25\n", + "a = 12345678\n", + "b = 0.02\n", + "print(f'I am {age:_>8.2f} years old, and my name is {name:-<10}. | {a:,} | {b:.0%} | {a:.3e}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 解包\n", + "\n", + "使用 `*` 可以解包" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 3\n" + ] + } + ], + "source": [ + "my_list = [1, 2, 3]\n", + "print(*my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 2, 3)\n", + "1 2 3 " + ] + } + ], + "source": [ + "def my_func(*args):\n", + " print(args)\n", + " for arg in args:\n", + " print(arg, end=' ')\n", + "my_func(1, 2, 3)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 循环\n", + "\n", + "```py\n", + "for 变量 in 序列:\n", + " # 执行代码块\n", + "```\n", + "\n", + "```py\n", + "while 条件表达式:\n", + " # 条件表达式为真则执行代码块\n", + "```\n", + "\n", + "for 循环中的 `序列` 可以是任何可迭代对象，包括列表(list)、元组(tuple)、字符串(str)、字典(dict)、集合(set)等。\n", + "\n", + "for 循环中的 `变量` 对应序列中的每个元素。 当使用 **序列解包(Sequence Unpacking)** 时, 序列中的元素可以赋值个多个变量\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1 `range()` 常用于生成 for 循环的序列\n", + "\n", + "```py\n", + "range(stop)\n", + "range(start, stop[, step])\n", + "```\n", + "其中：\n", + "\n", + "- `stop`: 生成的整数序列终止值（不包含）。\n", + "- `start`: 生成的整数序列起始值（包含，默认为 0）。\n", + "- `step`: 整数序列的步长大小（默认为 1）。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2 `enumerate()` 用于迭代序列时跟踪索引\n", + "\n", + "```py\n", + "enumerate(sequence, start=0)\n", + "```\n", + "\n", + "其中:\n", + "- `sequence`: 要迭代的序列\n", + "- `start`: 索引开始的值\n", + "- 返回一个由 **索引** 和 **序列元素** 组成的枚举对象\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3 `reversed()` 可将一个可迭代对象的反转。 可用来反向遍历数组\n", + "\n", + "```py\n", + "reversed(sequence)\n", + "```\n", + "其中\n", + "- `sequence` 是一个可迭代对象，可以是列表、元组、字符串等。\n", + "- 返回反转后的迭代器。 如有需要, 可再套层 `list()` 将其转换为列表。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 4 3 2 1 " + ] + } + ], + "source": [ + "a = [1, 2, 3, 4, 5]\n", + "for i in reversed(a):\n", + " print(i, end=' ')" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1 2 3 4 " + ] + } + ], + "source": [ + "for i in range(5):\n", + " print(i, end=' ')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 3 4 " + ] + } + ], + "source": [ + "for i in range(1, 5):\n", + " print(i, end=' ')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 0 -1 -2 -3 -4 " + ] + } + ], + "source": [ + "for i in range(1, -5, -1):\n", + " print(i, end=' ')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 3 4 " + ] + } + ], + "source": [ + "for i in range(1, 5):\n", + " print(i, end=' ')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Alice is female.\n", + "Bob is male.\n", + "Charlie is male.\n" + ] + } + ], + "source": [ + "people = [('Alice', 18, 'female'), ('Bob', 22, 'male'), ('Charlie', 25, 'male')]\n", + "for name, _, gender in people:\n", + " print(f\"{name} is {gender}.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "66 apple\n", + "67 banana\n", + "68 cherry\n" + ] + } + ], + "source": [ + "fruits = ['apple', 'banana', 'cherry']\n", + "for index, fruit in enumerate(fruits, 66):\n", + " print(index, fruit)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/python basics/\346\230\223\351\224\231\347\202\271\342\235\214.ipynb" "b/python/python basics/\346\230\223\351\224\231\347\202\271\342\235\214.ipynb" new file mode 100644 index 0000000..3e49950 --- /dev/null +++ "b/python/python basics/\346\230\223\351\224\231\347\202\271\342\235\214.ipynb" @@ -0,0 +1,40 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "闭包函数内无法修改基本类型变量" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def f1():\n", + " b = 1\n", + " c = [0]\n", + " def f2() :\n", + " try:\n", + " # 这样是不行的\n", + " b += 1\n", + " except:\n", + " print('❌')\n", + " pass\n", + " c[0] += 1 # 这样才可以\n", + " f2()\n", + "f1()" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/stdlib(Standard Library)/datastruct.ipynb b/python/stdlib(Standard Library)/datastruct.ipynb new file mode 100644 index 0000000..5f58a74 --- /dev/null +++ b/python/stdlib(Standard Library)/datastruct.ipynb @@ -0,0 +1,320 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 哈希表" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 注意, 添加近 set 的内容必须是可以 hash 的, 而 list 是无法 hash 的\n", + "s = set()\n", + "# s.add([1, 2]) ❌" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1}\n", + "set()\n" + ] + } + ], + "source": [ + "_set = set()\n", + "_set.add(1)\n", + "if 1 in _set:\n", + " print(_set)\n", + " _set.remove(1)\n", + "print(_set)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Map\n", + "\n", + "注意判断是否存在该键时, 要使用 `in` 判断, 而不是 `is None`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "{}\n", + "{None: None}\n", + "False\n" + ] + } + ], + "source": [ + "# 创建\n", + "_map = {}\n", + "_map[1] = 2\n", + "\n", + "# 修改\n", + "_map[1] = 3\n", + "\n", + "# 删除\n", + "print(_map.pop(1))\n", + "\n", + "# 查找, 不存在也会为 None\n", + "print(_map) \n", + "_map[None] = None\n", + "print(_map) \n", + "_map.get(None)\n", + "\n", + "# 判断\n", + "if _map.get(1) is None:\n", + " print(1 in _map)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from collections import defaultdict\n", + "a = defaultdict(set)\n", + "a[0].add(1)\n", + "a[0].add(1)\n", + "a[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "123\n" + ] + } + ], + "source": [ + "# 使用 defaultdict 可以在访问不存在的值时, 返回默认值\n", + "from collections import defaultdict\n", + "\n", + "d = defaultdict(int) # int, list, set\n", + "print(d['a']) # 输出: 0\n", + "\n", + "# 想要指定返回值时, 可以使用函数\n", + "def f():\n", + " return '123'\n", + "d = defaultdict(f)\n", + "print(d['a'])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 有序表" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3, 1]\n", + "[2, 2]\n", + "[1, 3]\n" + ] + } + ], + "source": [ + "from queue import PriorityQueue\n", + "\n", + "class MyObject:\n", + " def __init__(self, a, b):\n", + " self.val = [a,b]\n", + "\n", + " def __lt__(self, other):\n", + " # 定义对象之间的比较规则: 从小到大\n", + " return self.val[1] < other.val[1]\n", + "\n", + "# 创建一个 PriorityQueue 对象\n", + "pq = PriorityQueue()\n", + "\n", + "# 创建一些对象并添加到优先级队列中\n", + "pq.put(MyObject(1, 3))\n", + "pq.put(MyObject(2, 2))\n", + "pq.put(MyObject(3, 1))\n", + "\n", + "# 从优先级队列中取出对象\n", + "while not pq.empty():\n", + " print(pq.get().val)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 5, 7]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import heapq\n", + "\n", + "heap = []\n", + "\n", + "heapq.heappush(heap, 5)\n", + "heapq.heappush(heap, 2)\n", + "heapq.heappush(heap, 7)\n", + "\n", + "heap" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 队列" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "queue 中的 Queue 可以创建队列\n", + "\n", + "常见函数有:\n", + "- `put()` 添加元素\n", + "- `get()` 弹出元素\n", + "- `empty()` 判断队列是否为空\n", + "- `qsize()` 返回队列元素数量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "0\n", + "True\n" + ] + } + ], + "source": [ + "from queue import Queue\n", + "\n", + "queue = Queue()\n", + "queue.put(1)\n", + "print(queue.get(1))\n", + "print(queue.qsize())\n", + "print(queue.empty())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "利用数组也可以实现队列" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "[2, 3]\n", + "[2, 3, 4]\n" + ] + } + ], + "source": [ + "queue = [1,2,3]\n", + "print(queue.pop(0))\n", + "print(queue)\n", + "queue.append(4)\n", + "print(queue)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/stdlib(Standard Library)/functools.ipynb b/python/stdlib(Standard Library)/functools.ipynb new file mode 100644 index 0000000..06ece84 --- /dev/null +++ b/python/stdlib(Standard Library)/functools.ipynb @@ -0,0 +1,78 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "functools 模块" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## cmp_to_key\n", + "\n", + "可用于定义比较器" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[12, 86, 45, 1, 7, 83, 64, 95, 72, 71]\n", + "[95, 86, 83, 72, 71, 64, 45, 12, 7, 1]\n", + "[1, 7, 12, 45, 64, 71, 72, 83, 86, 95]\n" + ] + } + ], + "source": [ + "from functools import cmp_to_key\n", + "import random\n", + "\n", + "\n", + "def cmp(a, b):\n", + " return b-a\n", + "\n", + "\n", + "arr = [random.randint(1, 100) for _ in range(10)]\n", + "print(arr)\n", + "\n", + "sort_arr = sorted(arr, key=cmp_to_key(cmp))\n", + "print(sort_arr)\n", + "\n", + "sort_arr = sorted(arr, key=cmp_to_key(lambda a, b: a-b))\n", + "print(sort_arr)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/stdlib(Standard Library)/random.ipynb b/python/stdlib(Standard Library)/random.ipynb new file mode 100644 index 0000000..5cde2b2 --- /dev/null +++ b/python/stdlib(Standard Library)/random.ipynb @@ -0,0 +1,82 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```py\n", + "random.randint(a, b)\n", + "```\n", + "其中:\n", + "- `a` 和 `b` 是两个整数，表示生成的随机整数的范围为 `[a, b]`。 注意 a 不能大于 b\n", + "- 返回值: 是一个在该范围内的随机整数。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下面这段代码可以随机生成100个范围在100-200之间的随机整数\n", + "```py\n", + "import random\n", + "numbers = [random.randint(100, 200) for i in range(100)]\n", + "```\n", + "- `numbers`：这是我们要生成的包含100个随机整数的列表。\n", + "- `random.randint(100, 200)`：这是我们使用的函数，它将生成一个介于100和200之间的随机整数。\n", + "- `[...]`：这是Python中的列表推导式语法。它允许我们在一行代码中创建一个新的列表，并基于已有的数据进行转换或筛选。\n", + "- `for i in range(100)`：这是一个循环语句，它将运行100次。在每次迭代中，我们将生成一个新的随机整数，并将其添加到列表中。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## shuffle 打乱数组" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6, 7, 0, 5, 2, 1, 9, 4, 8, 3]\n" + ] + } + ], + "source": [ + "import random\n", + "a = [i for i in range(10)]\n", + "random.shuffle(a)\n", + "print(a)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/stdlib(Standard Library)/sys.ipynb b/python/stdlib(Standard Library)/sys.ipynb new file mode 100644 index 0000000..23d5f73 --- /dev/null +++ b/python/stdlib(Standard Library)/sys.ipynb @@ -0,0 +1,93 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 处理输入" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```py\n", + "import sys\n", + "# 读取第一行数据\n", + "first_line = sys.stdin.readline()\n", + "# 读取第一行中以空格分隔开的各个数据\n", + "first_items = first_line.split()\n", + "```\n", + "\n", + "```py \n", + "import sys\n", + "# 一次读取完多行数据\n", + "for line in sys.stdin:\n", + " line_items = line.split()\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ACM 模式输入模版\n", + "\n", + "```py\n", + "import sys\n", + "input = sys.stdin.readline\n", + "\n", + "for _ in range(行数):\n", + " ... = map(int, input().split())\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9223372036854775807" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 系统整数最大值\n", + "import sys \n", + "sys.maxsize" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/stdlib(Standard Library)/typing.ipynb b/python/stdlib(Standard Library)/typing.ipynb new file mode 100644 index 0000000..7defe94 --- /dev/null +++ b/python/stdlib(Standard Library)/typing.ipynb @@ -0,0 +1,72 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Python 类型提示\n", + "\n", + "如果没有对应的插件, 类型出错时并不会报错。" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`typing` 模块有常用类型:\n", + "- `List`\n", + "- `Set`\n", + "- `Mapping`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] {1: '1'} {'1'}\n" + ] + } + ], + "source": [ + "from typing import List, Mapping, Set\n", + "\n", + "\n", + "def f(arr: List[int] = [1], m: Mapping[int, str] = {1: '1'}, s: Set[str] = set()):\n", + " s.add('1')\n", + " print(arr, m, s)\n", + "\n", + "\n", + "f()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/stdlib(Standard Library)/\345\270\270\347\224\250\345\272\223.ipynb" "b/python/stdlib(Standard Library)/\345\270\270\347\224\250\345\272\223.ipynb" new file mode 100644 index 0000000..f4a6519 --- /dev/null +++ "b/python/stdlib(Standard Library)/\345\270\270\347\224\250\345\272\223.ipynb" @@ -0,0 +1,52 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'我是默认值'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from collections import defaultdict\n", + "\n", + "a = defaultdict(list)\n", + "a[0] # 输出空数组。原因在于调用 list() 函数时返回一个空数组\n", + "\n", + "b = defaultdict(lambda:'我是默认值')\n", + "b[0] # 输出 “我是默认值”，原因在于调用第一个参数（函数）时返回 '我是默认值'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/stdlib(Standard Library)/\346\226\207\344\273\266\345\244\204\347\220\206.ipynb" "b/python/stdlib(Standard Library)/\346\226\207\344\273\266\345\244\204\347\220\206.ipynb" new file mode 100644 index 0000000..ccdc347 --- /dev/null +++ "b/python/stdlib(Standard Library)/\346\226\207\344\273\266\345\244\204\347\220\206.ipynb" @@ -0,0 +1,91 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `with open('input.txt', 'r') as file` " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 使用 with 语句打开名为 fileinput.txt 的文件，并以只读模式 (\"r\") 读取文件\n", + "with open(\"fileinput.txt\", \"r\") as file:\n", + " lines = file.readlines()\n", + "num = int(lines[0].strip()) # 一行一个数\n", + "nums = list(map(int, lines[1].strip().split())) # 一行多个数字" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## shutil" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```py\n", + "import shutil\n", + "\n", + "# 拷贝文件，将源文件拷贝到目标路径下，并且保留文件名\n", + "shutil.copy('/path/to/source/file', '/path/to/destination')\n", + "\n", + "# 拷贝文件，将源文件拷贝到目标路径下，并指定新的文件名\n", + "shutil.copy('/path/to/source/file', '/path/to/destination/new_file_name')\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 案例" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "current_directory = os.getcwd()\n", + "print(current_directory)\n", + "\n", + "# 列出当前文件夹中的所有文件\n", + "files = os.listdir('./')\n", + "\n", + "for file in files:\n", + " if file.endswith(\"（自动生成）.srt\"):\n", + " # 构建新的文件名\n", + " new_file_name = file.replace(\"（自动生成）.srt\", \".srt\")\n", + " # 重命名文件\n", + " os.rename(file, new_file_name)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/tmpmd b/python/tmpmd new file mode 100644 index 0000000..815e0b9 --- /dev/null +++ b/python/tmpmd @@ -0,0 +1,6 @@ +# tmp + +```py +import sys +sys.setrecursionlimit(10**8) +``` diff --git "a/python/\346\216\247\345\210\266py\350\277\220\350\241\214\346\227\266\351\227\264/\346\216\247\345\210\266py\350\277\220\350\241\214\346\227\266\351\227\264.ipynb" "b/python/\346\216\247\345\210\266py\350\277\220\350\241\214\346\227\266\351\227\264/\346\216\247\345\210\266py\350\277\220\350\241\214\346\227\266\351\227\264.ipynb" new file mode 100644 index 0000000..cf31ada --- /dev/null +++ "b/python/\346\216\247\345\210\266py\350\277\220\350\241\214\346\227\266\351\227\264/\346\216\247\345\210\266py\350\277\220\350\241\214\346\227\266\351\227\264.ipynb" @@ -0,0 +1,84 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 借助 [func_timeout](https://github.com/kata198/func_timeout) 模块实现。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[原生实现](https://zhuanlan.zhihu.com/p/390143037)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "from func_timeout import func_timeout, FunctionTimedOut\n", + "\n", + "def limit_time(limit, doit, args):\n", + "\ttry:\n", + "\t\tdoitReturnValue = func_timeout(limit, doit, args)\n", + "\t\treturn False, doitReturnValue\n", + "\texcept FunctionTimedOut:\n", + "\t\treturn True, '超时'\n", + "\texcept Exception as e:\n", + "\t\treturn True, '出错'\n" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "def do_something(a, b):\n", + " for i in range(999999):\n", + " i += 1\n", + " return a + b\n", + "\n", + "timeout, return_val = limit_time(0.001, do_something, (1, 2))\n", + "if timeout:\n", + " print('❌', return_val)\n", + "else:\n", + " print(return_val)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/python/\347\210\254\345\217\226\345\274\271\345\271\225/bili_pb2.py" "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/bili_pb2.py" new file mode 100644 index 0000000..4607bf4 --- /dev/null +++ "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/bili_pb2.py" @@ -0,0 +1,3492 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: my.proto + +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='my.proto', + package='bilibili.community.service.dm.v1', + syntax='proto3', + serialized_options=None, + create_key=_descriptor._internal_create_key, + serialized_pb=b'\n\x08my.proto\x12 bilibili.community.service.dm.v1\"X\n\x0e\x42uzzwordConfig\x12\x46\n\x08keywords\x18\x01 \x03(\x0b\x32\x34.bilibili.community.service.dm.v1.BuzzwordShowConfig\"x\n\x12\x42uzzwordShowConfig\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06schema\x18\x02 \x01(\t\x12\x0e\n\x06source\x18\x03 \x01(\x05\x12\n\n\x02id\x18\x04 \x01(\x03\x12\x13\n\x0b\x62uzzword_id\x18\x05 \x01(\x03\x12\x13\n\x0bschema_type\x18\x06 \x01(\x05\"\xa1\x01\n\tCommandDm\x12\n\n\x02id\x18\x01 \x01(\x03\x12\x0b\n\x03oid\x18\x02 \x01(\x03\x12\x0b\n\x03mid\x18\x03 \x01(\t\x12\x0f\n\x07\x63ommand\x18\x04 \x01(\t\x12\x0f\n\x07\x63ontent\x18\x05 \x01(\t\x12\x10\n\x08progress\x18\x06 \x01(\x05\x12\r\n\x05\x63time\x18\x07 \x01(\t\x12\r\n\x05mtime\x18\x08 \x01(\t\x12\r\n\x05\x65xtra\x18\t \x01(\t\x12\r\n\x05idStr\x18\n \x01(\t\"P\n\rDanmakuAIFlag\x12?\n\x08\x64m_flags\x18\x01 \x03(\x0b\x32-.bilibili.community.service.dm.v1.DanmakuFlag\"\xd6\x01\n\x0b\x44\x61nmakuElem\x12\n\n\x02id\x18\x01 \x01(\x03\x12\x10\n\x08progress\x18\x02 \x01(\x05\x12\x0c\n\x04mode\x18\x03 \x01(\x05\x12\x10\n\x08\x66ontsize\x18\x04 \x01(\x05\x12\r\n\x05\x63olor\x18\x05 \x01(\r\x12\x0f\n\x07midHash\x18\x06 \x01(\t\x12\x0f\n\x07\x63ontent\x18\x07 \x01(\t\x12\r\n\x05\x63time\x18\x08 \x01(\x03\x12\x0e\n\x06weight\x18\t \x01(\x05\x12\x0e\n\x06\x61\x63tion\x18\n \x01(\t\x12\x0c\n\x04pool\x18\x0b \x01(\x05\x12\r\n\x05idStr\x18\x0c \x01(\t\x12\x0c\n\x04\x61ttr\x18\r \x01(\x05\")\n\x0b\x44\x61nmakuFlag\x12\x0c\n\x04\x64mid\x18\x01 \x01(\x03\x12\x0c\n\x04\x66lag\x18\x02 \x01(\r\"K\n\x11\x44\x61nmakuFlagConfig\x12\x10\n\x08rec_flag\x18\x01 \x01(\x05\x12\x10\n\x08rec_text\x18\x02 \x01(\t\x12\x12\n\nrec_switch\x18\x03 \x01(\x05\"\xcc\x04\n\x18\x44\x61nmuDefaultPlayerConfig\x12)\n!player_danmaku_use_default_config\x18\x01 \x01(\x08\x12,\n$player_danmaku_ai_recommended_switch\x18\x04 \x01(\x08\x12+\n#player_danmaku_ai_recommended_level\x18\x05 \x01(\x05\x12\x1f\n\x17player_danmaku_blocktop\x18\x06 \x01(\x08\x12\"\n\x1aplayer_danmaku_blockscroll\x18\x07 \x01(\x08\x12\"\n\x1aplayer_danmaku_blockbottom\x18\x08 \x01(\x08\x12$\n\x1cplayer_danmaku_blockcolorful\x18\t \x01(\x08\x12\"\n\x1aplayer_danmaku_blockrepeat\x18\n \x01(\x08\x12#\n\x1bplayer_danmaku_blockspecial\x18\x0b \x01(\x08\x12\x1e\n\x16player_danmaku_opacity\x18\x0c \x01(\x02\x12$\n\x1cplayer_danmaku_scalingfactor\x18\r \x01(\x02\x12\x1d\n\x15player_danmaku_domain\x18\x0e \x01(\x02\x12\x1c\n\x14player_danmaku_speed\x18\x0f \x01(\x05\x12$\n\x1cinline_player_danmaku_switch\x18\x10 \x01(\x08\x12)\n!player_danmaku_senior_mode_switch\x18\x11 \x01(\x05\"\xfe\x05\n\x11\x44\x61nmuPlayerConfig\x12\x1d\n\x15player_danmaku_switch\x18\x01 \x01(\x08\x12\"\n\x1aplayer_danmaku_switch_save\x18\x02 \x01(\x08\x12)\n!player_danmaku_use_default_config\x18\x03 \x01(\x08\x12,\n$player_danmaku_ai_recommended_switch\x18\x04 \x01(\x08\x12+\n#player_danmaku_ai_recommended_level\x18\x05 \x01(\x05\x12\x1f\n\x17player_danmaku_blocktop\x18\x06 \x01(\x08\x12\"\n\x1aplayer_danmaku_blockscroll\x18\x07 \x01(\x08\x12\"\n\x1aplayer_danmaku_blockbottom\x18\x08 \x01(\x08\x12$\n\x1cplayer_danmaku_blockcolorful\x18\t \x01(\x08\x12\"\n\x1aplayer_danmaku_blockrepeat\x18\n \x01(\x08\x12#\n\x1bplayer_danmaku_blockspecial\x18\x0b \x01(\x08\x12\x1e\n\x16player_danmaku_opacity\x18\x0c \x01(\x02\x12$\n\x1cplayer_danmaku_scalingfactor\x18\r \x01(\x02\x12\x1d\n\x15player_danmaku_domain\x18\x0e \x01(\x02\x12\x1c\n\x14player_danmaku_speed\x18\x0f \x01(\x05\x12&\n\x1eplayer_danmaku_enableblocklist\x18\x10 \x01(\x08\x12$\n\x1cinline_player_danmaku_switch\x18\x11 \x01(\x08\x12$\n\x1cinline_player_danmaku_config\x18\x12 \x01(\x05\x12&\n\x1eplayer_danmaku_ios_switch_save\x18\x13 \x01(\x05\x12)\n!player_danmaku_senior_mode_switch\x18\x14 \x01(\x05\"K\n\x18\x44\x61nmuPlayerDynamicConfig\x12\x10\n\x08progress\x18\x01 \x01(\x05\x12\x1d\n\x15player_danmaku_domain\x18\x0e \x01(\x02\"\xb1\x02\n\x15\x44\x61nmuPlayerViewConfig\x12\x61\n\x1d\x64\x61nmuku_default_player_config\x18\x01 \x01(\x0b\x32:.bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig\x12R\n\x15\x64\x61nmuku_player_config\x18\x02 \x01(\x0b\x32\x33.bilibili.community.service.dm.v1.DanmuPlayerConfig\x12\x61\n\x1d\x64\x61nmuku_player_dynamic_config\x18\x03 \x03(\x0b\x32:.bilibili.community.service.dm.v1.DanmuPlayerDynamicConfig\"\xab\x03\n\x14\x44\x61nmuWebPlayerConfig\x12\x11\n\tdm_switch\x18\x01 \x01(\x08\x12\x11\n\tai_switch\x18\x02 \x01(\x08\x12\x10\n\x08\x61i_level\x18\x03 \x01(\x05\x12\x10\n\x08\x62locktop\x18\x04 \x01(\x08\x12\x13\n\x0b\x62lockscroll\x18\x05 \x01(\x08\x12\x13\n\x0b\x62lockbottom\x18\x06 \x01(\x08\x12\x12\n\nblockcolor\x18\x07 \x01(\x08\x12\x14\n\x0c\x62lockspecial\x18\x08 \x01(\x08\x12\x14\n\x0cpreventshade\x18\t \x01(\x08\x12\r\n\x05\x64mask\x18\n \x01(\x08\x12\x0f\n\x07opacity\x18\x0b \x01(\x02\x12\x0e\n\x06\x64marea\x18\x0c \x01(\x05\x12\x11\n\tspeedplus\x18\r \x01(\x02\x12\x10\n\x08\x66ontsize\x18\x0e \x01(\x02\x12\x12\n\nscreensync\x18\x0f \x01(\x08\x12\x11\n\tspeedsync\x18\x10 \x01(\x08\x12\x12\n\nfontfamily\x18\x11 \x01(\t\x12\x0c\n\x04\x62old\x18\x12 \x01(\x08\x12\x12\n\nfontborder\x18\x13 \x01(\x05\x12\x11\n\tdraw_type\x18\x14 \x01(\t\x12\x1a\n\x12senior_mode_switch\x18\x15 \x01(\x05\"A\n\x0f\x44mExpoReportReq\x12\x12\n\nsession_id\x18\x01 \x01(\t\x12\x0b\n\x03oid\x18\x02 \x01(\x03\x12\r\n\x05spmid\x18\x04 \x01(\t\"\x11\n\x0f\x44mExpoReportRes\"\xfd\x0b\n\x11\x44mPlayerConfigReq\x12\n\n\x02ts\x18\x01 \x01(\x03\x12\x45\n\x06switch\x18\x02 \x01(\x0b\x32\x35.bilibili.community.service.dm.v1.PlayerDanmakuSwitch\x12N\n\x0bswitch_save\x18\x03 \x01(\x0b\x32\x39.bilibili.community.service.dm.v1.PlayerDanmakuSwitchSave\x12[\n\x12use_default_config\x18\x04 \x01(\x0b\x32?.bilibili.community.service.dm.v1.PlayerDanmakuUseDefaultConfig\x12\x61\n\x15\x61i_recommended_switch\x18\x05 \x01(\x0b\x32\x42.bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedSwitch\x12_\n\x14\x61i_recommended_level\x18\x06 \x01(\x0b\x32\x41.bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedLevel\x12I\n\x08\x62locktop\x18\x07 \x01(\x0b\x32\x37.bilibili.community.service.dm.v1.PlayerDanmakuBlocktop\x12O\n\x0b\x62lockscroll\x18\x08 \x01(\x0b\x32:.bilibili.community.service.dm.v1.PlayerDanmakuBlockscroll\x12O\n\x0b\x62lockbottom\x18\t \x01(\x0b\x32:.bilibili.community.service.dm.v1.PlayerDanmakuBlockbottom\x12S\n\rblockcolorful\x18\n \x01(\x0b\x32<.bilibili.community.service.dm.v1.PlayerDanmakuBlockcolorful\x12O\n\x0b\x62lockrepeat\x18\x0b \x01(\x0b\x32:.bilibili.community.service.dm.v1.PlayerDanmakuBlockrepeat\x12Q\n\x0c\x62lockspecial\x18\x0c \x01(\x0b\x32;.bilibili.community.service.dm.v1.PlayerDanmakuBlockspecial\x12G\n\x07opacity\x18\r \x01(\x0b\x32\x36.bilibili.community.service.dm.v1.PlayerDanmakuOpacity\x12S\n\rscalingfactor\x18\x0e \x01(\x0b\x32<.bilibili.community.service.dm.v1.PlayerDanmakuScalingfactor\x12\x45\n\x06\x64omain\x18\x0f \x01(\x0b\x32\x35.bilibili.community.service.dm.v1.PlayerDanmakuDomain\x12\x43\n\x05speed\x18\x10 \x01(\x0b\x32\x34.bilibili.community.service.dm.v1.PlayerDanmakuSpeed\x12W\n\x0f\x65nableblocklist\x18\x11 \x01(\x0b\x32>.bilibili.community.service.dm.v1.PlayerDanmakuEnableblocklist\x12^\n\x19inlinePlayerDanmakuSwitch\x18\x12 \x01(\x0b\x32;.bilibili.community.service.dm.v1.InlinePlayerDanmakuSwitch\x12[\n\x12senior_mode_switch\x18\x13 \x01(\x0b\x32?.bilibili.community.service.dm.v1.PlayerDanmakuSeniorModeSwitch\"/\n\x0b\x44mSegConfig\x12\x11\n\tpage_size\x18\x01 \x01(\x03\x12\r\n\x05total\x18\x02 \x01(\x03\"\xa1\x01\n\x10\x44mSegMobileReply\x12<\n\x05\x65lems\x18\x01 \x03(\x0b\x32-.bilibili.community.service.dm.v1.DanmakuElem\x12\r\n\x05state\x18\x02 \x01(\x05\x12@\n\x07\x61i_flag\x18\x03 \x01(\x0b\x32/.bilibili.community.service.dm.v1.DanmakuAIFlag\"g\n\x0e\x44mSegMobileReq\x12\x0b\n\x03pid\x18\x01 \x01(\x03\x12\x0b\n\x03oid\x18\x02 \x01(\x03\x12\x0c\n\x04type\x18\x03 \x01(\x05\x12\x15\n\rsegment_index\x18\x04 \x01(\x03\x12\x16\n\x0eteenagers_mode\x18\x05 \x01(\x05\"]\n\rDmSegOttReply\x12\x0e\n\x06\x63losed\x18\x01 \x01(\x08\x12<\n\x05\x65lems\x18\x02 \x03(\x0b\x32-.bilibili.community.service.dm.v1.DanmakuElem\"L\n\x0b\x44mSegOttReq\x12\x0b\n\x03pid\x18\x01 \x01(\x03\x12\x0b\n\x03oid\x18\x02 \x01(\x03\x12\x0c\n\x04type\x18\x03 \x01(\x05\x12\x15\n\rsegment_index\x18\x04 \x01(\x03\"]\n\rDmSegSDKReply\x12\x0e\n\x06\x63losed\x18\x01 \x01(\x08\x12<\n\x05\x65lems\x18\x02 \x03(\x0b\x32-.bilibili.community.service.dm.v1.DanmakuElem\"L\n\x0b\x44mSegSDKReq\x12\x0b\n\x03pid\x18\x01 \x01(\x03\x12\x0b\n\x03oid\x18\x02 \x01(\x03\x12\x0c\n\x04type\x18\x03 \x01(\x05\x12\x15\n\rsegment_index\x18\x04 \x01(\x03\"\xc2\x05\n\x0b\x44mViewReply\x12\x0e\n\x06\x63losed\x18\x01 \x01(\x08\x12\x39\n\x04mask\x18\x02 \x01(\x0b\x32+.bilibili.community.service.dm.v1.VideoMask\x12\x41\n\x08subtitle\x18\x03 \x01(\x0b\x32/.bilibili.community.service.dm.v1.VideoSubtitle\x12\x13\n\x0bspecial_dms\x18\x04 \x03(\t\x12\x44\n\x07\x61i_flag\x18\x05 \x01(\x0b\x32\x33.bilibili.community.service.dm.v1.DanmakuFlagConfig\x12N\n\rplayer_config\x18\x06 \x01(\x0b\x32\x37.bilibili.community.service.dm.v1.DanmuPlayerViewConfig\x12\x16\n\x0esend_box_style\x18\x07 \x01(\x05\x12\r\n\x05\x61llow\x18\x08 \x01(\x08\x12\x11\n\tcheck_box\x18\t \x01(\t\x12\x1a\n\x12\x63heck_box_show_msg\x18\n \x01(\t\x12\x18\n\x10text_placeholder\x18\x0b \x01(\t\x12\x19\n\x11input_placeholder\x18\x0c \x01(\t\x12\x1d\n\x15report_filter_content\x18\r \x03(\t\x12\x41\n\x0b\x65xpo_report\x18\x0e \x01(\x0b\x32,.bilibili.community.service.dm.v1.ExpoReport\x12I\n\x0f\x62uzzword_config\x18\x0f \x01(\x0b\x32\x30.bilibili.community.service.dm.v1.BuzzwordConfig\x12\x42\n\x0b\x65xpressions\x18\x10 \x03(\x0b\x32-.bilibili.community.service.dm.v1.Expressions\"X\n\tDmViewReq\x12\x0b\n\x03pid\x18\x01 \x01(\x03\x12\x0b\n\x03oid\x18\x02 \x01(\x03\x12\x0c\n\x04type\x18\x03 \x01(\x05\x12\r\n\x05spmid\x18\x04 \x01(\t\x12\x14\n\x0cis_hard_boot\x18\x05 \x01(\x05\"\xec\x03\n\x0e\x44mWebViewReply\x12\r\n\x05state\x18\x01 \x01(\x05\x12\x0c\n\x04text\x18\x02 \x01(\t\x12\x11\n\ttext_side\x18\x03 \x01(\t\x12=\n\x06\x64m_sge\x18\x04 \x01(\x0b\x32-.bilibili.community.service.dm.v1.DmSegConfig\x12\x41\n\x04\x66lag\x18\x05 \x01(\x0b\x32\x33.bilibili.community.service.dm.v1.DanmakuFlagConfig\x12\x13\n\x0bspecial_dms\x18\x06 \x03(\t\x12\x11\n\tcheck_box\x18\x07 \x01(\x08\x12\r\n\x05\x63ount\x18\x08 \x01(\x03\x12?\n\ncommandDms\x18\t \x03(\x0b\x32+.bilibili.community.service.dm.v1.CommandDm\x12M\n\rplayer_config\x18\n \x01(\x0b\x32\x36.bilibili.community.service.dm.v1.DanmuWebPlayerConfig\x12\x1d\n\x15report_filter_content\x18\x0b \x03(\t\x12\x42\n\x0b\x65xpressions\x18\x0c \x03(\x0b\x32-.bilibili.community.service.dm.v1.Expressions\"*\n\nExpoReport\x12\x1c\n\x14should_report_at_end\x18\x01 \x01(\x08\"d\n\nExpression\x12\x0f\n\x07keyword\x18\x01 \x03(\t\x12\x0b\n\x03url\x18\x02 \x01(\t\x12\x38\n\x06period\x18\x03 \x03(\x0b\x32(.bilibili.community.service.dm.v1.Period\"I\n\x0b\x45xpressions\x12:\n\x04\x64\x61ta\x18\x01 \x03(\x0b\x32,.bilibili.community.service.dm.v1.Expression\"$\n\x06Period\x12\r\n\x05start\x18\x01 \x01(\x03\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x03\"*\n\x19InlinePlayerDanmakuSwitch\x12\r\n\x05value\x18\x01 \x01(\x08\"0\n\x1fPlayerDanmakuAiRecommendedLevel\x12\r\n\x05value\x18\x01 \x01(\x08\"1\n PlayerDanmakuAiRecommendedSwitch\x12\r\n\x05value\x18\x01 \x01(\x08\")\n\x18PlayerDanmakuBlockbottom\x12\r\n\x05value\x18\x01 \x01(\x08\"+\n\x1aPlayerDanmakuBlockcolorful\x12\r\n\x05value\x18\x01 \x01(\x08\")\n\x18PlayerDanmakuBlockrepeat\x12\r\n\x05value\x18\x01 \x01(\x08\")\n\x18PlayerDanmakuBlockscroll\x12\r\n\x05value\x18\x01 \x01(\x08\"*\n\x19PlayerDanmakuBlockspecial\x12\r\n\x05value\x18\x01 \x01(\x08\"&\n\x15PlayerDanmakuBlocktop\x12\r\n\x05value\x18\x01 \x01(\x08\"$\n\x13PlayerDanmakuDomain\x12\r\n\x05value\x18\x01 \x01(\x02\"-\n\x1cPlayerDanmakuEnableblocklist\x12\r\n\x05value\x18\x01 \x01(\x08\"%\n\x14PlayerDanmakuOpacity\x12\r\n\x05value\x18\x01 \x01(\x02\"+\n\x1aPlayerDanmakuScalingfactor\x12\r\n\x05value\x18\x01 \x01(\x02\".\n\x1dPlayerDanmakuSeniorModeSwitch\x12\r\n\x05value\x18\x01 \x01(\x05\"#\n\x12PlayerDanmakuSpeed\x12\r\n\x05value\x18\x01 \x01(\x05\"7\n\x13PlayerDanmakuSwitch\x12\r\n\x05value\x18\x01 \x01(\x08\x12\x11\n\tcanIgnore\x18\x02 \x01(\x08\"(\n\x17PlayerDanmakuSwitchSave\x12\r\n\x05value\x18\x01 \x01(\x08\".\n\x1dPlayerDanmakuUseDefaultConfig\x12\r\n\x05value\x18\x01 \x01(\x08\")\n\x08Response\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\t\"\xd8\x01\n\x0cSubtitleItem\x12\n\n\x02id\x18\x01 \x01(\x03\x12\x0e\n\x06id_str\x18\x02 \x01(\t\x12\x0b\n\x03lan\x18\x03 \x01(\t\x12\x0f\n\x07lan_doc\x18\x04 \x01(\t\x12\x14\n\x0csubtitle_url\x18\x05 \x01(\t\x12:\n\x06\x61uthor\x18\x06 \x01(\x0b\x32*.bilibili.community.service.dm.v1.UserInfo\x12<\n\x04type\x18\x07 \x01(\x0e\x32..bilibili.community.service.dm.v1.SubtitleType\"\\\n\x08UserInfo\x12\x0b\n\x03mid\x18\x01 \x01(\x03\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x0b\n\x03sex\x18\x03 \x01(\t\x12\x0c\n\x04\x66\x61\x63\x65\x18\x04 \x01(\t\x12\x0c\n\x04sign\x18\x05 \x01(\t\x12\x0c\n\x04rank\x18\x06 \x01(\x05\"S\n\tVideoMask\x12\x0b\n\x03\x63id\x18\x01 \x01(\x03\x12\x0c\n\x04plat\x18\x02 \x01(\x05\x12\x0b\n\x03\x66ps\x18\x03 \x01(\x05\x12\x0c\n\x04time\x18\x04 \x01(\x03\x12\x10\n\x08mask_url\x18\x05 \x01(\t\"o\n\rVideoSubtitle\x12\x0b\n\x03lan\x18\x01 \x01(\t\x12\x0e\n\x06lanDoc\x18\x02 \x01(\t\x12\x41\n\tsubtitles\x18\x03 \x03(\x0b\x32..bilibili.community.service.dm.v1.SubtitleItem*L\n\tDMAttrBit\x12\x14\n\x10\x44MAttrBitProtect\x10\x00\x12\x15\n\x11\x44MAttrBitFromLive\x10\x01\x12\x12\n\x0e\x44MAttrHighLike\x10\x02*\x1e\n\x0cSubtitleType\x12\x06\n\x02\x43\x43\x10\x00\x12\x06\n\x02\x41I\x10\x01\x32\xa0\x05\n\x02\x44M\x12s\n\x0b\x44mSegMobile\x12\x30.bilibili.community.service.dm.v1.DmSegMobileReq\x1a\x32.bilibili.community.service.dm.v1.DmSegMobileReply\x12\x64\n\x06\x44mView\x12+.bilibili.community.service.dm.v1.DmViewReq\x1a-.bilibili.community.service.dm.v1.DmViewReply\x12q\n\x0e\x44mPlayerConfig\x12\x33.bilibili.community.service.dm.v1.DmPlayerConfigReq\x1a*.bilibili.community.service.dm.v1.Response\x12j\n\x08\x44mSegOtt\x12-.bilibili.community.service.dm.v1.DmSegOttReq\x1a/.bilibili.community.service.dm.v1.DmSegOttReply\x12j\n\x08\x44mSegSDK\x12-.bilibili.community.service.dm.v1.DmSegSDKReq\x1a/.bilibili.community.service.dm.v1.DmSegSDKReply\x12t\n\x0c\x44mExpoReport\x12\x31.bilibili.community.service.dm.v1.DmExpoReportReq\x1a\x31.bilibili.community.service.dm.v1.DmExpoReportResb\x06proto3' +) + +_DMATTRBIT = _descriptor.EnumDescriptor( + name='DMAttrBit', + full_name='bilibili.community.service.dm.v1.DMAttrBit', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='DMAttrBitProtect', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='DMAttrBitFromLive', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='DMAttrHighLike', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + serialized_start=8213, + serialized_end=8289, +) +_sym_db.RegisterEnumDescriptor(_DMATTRBIT) + +DMAttrBit = enum_type_wrapper.EnumTypeWrapper(_DMATTRBIT) +_SUBTITLETYPE = _descriptor.EnumDescriptor( + name='SubtitleType', + full_name='bilibili.community.service.dm.v1.SubtitleType', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='CC', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='AI', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + serialized_start=8291, + serialized_end=8321, +) +_sym_db.RegisterEnumDescriptor(_SUBTITLETYPE) + +SubtitleType = enum_type_wrapper.EnumTypeWrapper(_SUBTITLETYPE) +DMAttrBitProtect = 0 +DMAttrBitFromLive = 1 +DMAttrHighLike = 2 +CC = 0 +AI = 1 + + + +_BUZZWORDCONFIG = _descriptor.Descriptor( + name='BuzzwordConfig', + full_name='bilibili.community.service.dm.v1.BuzzwordConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='keywords', full_name='bilibili.community.service.dm.v1.BuzzwordConfig.keywords', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=46, + serialized_end=134, +) + + +_BUZZWORDSHOWCONFIG = _descriptor.Descriptor( + name='BuzzwordShowConfig', + full_name='bilibili.community.service.dm.v1.BuzzwordShowConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='bilibili.community.service.dm.v1.BuzzwordShowConfig.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='schema', full_name='bilibili.community.service.dm.v1.BuzzwordShowConfig.schema', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='source', full_name='bilibili.community.service.dm.v1.BuzzwordShowConfig.source', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='id', full_name='bilibili.community.service.dm.v1.BuzzwordShowConfig.id', index=3, + number=4, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='buzzword_id', full_name='bilibili.community.service.dm.v1.BuzzwordShowConfig.buzzword_id', index=4, + number=5, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='schema_type', full_name='bilibili.community.service.dm.v1.BuzzwordShowConfig.schema_type', index=5, + number=6, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=136, + serialized_end=256, +) + + +_COMMANDDM = _descriptor.Descriptor( + name='CommandDm', + full_name='bilibili.community.service.dm.v1.CommandDm', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='id', full_name='bilibili.community.service.dm.v1.CommandDm.id', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oid', full_name='bilibili.community.service.dm.v1.CommandDm.oid', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='mid', full_name='bilibili.community.service.dm.v1.CommandDm.mid', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='command', full_name='bilibili.community.service.dm.v1.CommandDm.command', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='content', full_name='bilibili.community.service.dm.v1.CommandDm.content', index=4, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='progress', full_name='bilibili.community.service.dm.v1.CommandDm.progress', index=5, + number=6, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ctime', full_name='bilibili.community.service.dm.v1.CommandDm.ctime', index=6, + number=7, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='mtime', full_name='bilibili.community.service.dm.v1.CommandDm.mtime', index=7, + number=8, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='extra', full_name='bilibili.community.service.dm.v1.CommandDm.extra', index=8, + number=9, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='idStr', full_name='bilibili.community.service.dm.v1.CommandDm.idStr', index=9, + number=10, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=259, + serialized_end=420, +) + + +_DANMAKUAIFLAG = _descriptor.Descriptor( + name='DanmakuAIFlag', + full_name='bilibili.community.service.dm.v1.DanmakuAIFlag', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='dm_flags', full_name='bilibili.community.service.dm.v1.DanmakuAIFlag.dm_flags', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=422, + serialized_end=502, +) + + +_DANMAKUELEM = _descriptor.Descriptor( + name='DanmakuElem', + full_name='bilibili.community.service.dm.v1.DanmakuElem', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='id', full_name='bilibili.community.service.dm.v1.DanmakuElem.id', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='progress', full_name='bilibili.community.service.dm.v1.DanmakuElem.progress', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='mode', full_name='bilibili.community.service.dm.v1.DanmakuElem.mode', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='fontsize', full_name='bilibili.community.service.dm.v1.DanmakuElem.fontsize', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='color', full_name='bilibili.community.service.dm.v1.DanmakuElem.color', index=4, + number=5, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='midHash', full_name='bilibili.community.service.dm.v1.DanmakuElem.midHash', index=5, + number=6, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='content', full_name='bilibili.community.service.dm.v1.DanmakuElem.content', index=6, + number=7, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ctime', full_name='bilibili.community.service.dm.v1.DanmakuElem.ctime', index=7, + number=8, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='weight', full_name='bilibili.community.service.dm.v1.DanmakuElem.weight', index=8, + number=9, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='action', full_name='bilibili.community.service.dm.v1.DanmakuElem.action', index=9, + number=10, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='pool', full_name='bilibili.community.service.dm.v1.DanmakuElem.pool', index=10, + number=11, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='idStr', full_name='bilibili.community.service.dm.v1.DanmakuElem.idStr', index=11, + number=12, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='attr', full_name='bilibili.community.service.dm.v1.DanmakuElem.attr', index=12, + number=13, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=505, + serialized_end=719, +) + + +_DANMAKUFLAG = _descriptor.Descriptor( + name='DanmakuFlag', + full_name='bilibili.community.service.dm.v1.DanmakuFlag', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='dmid', full_name='bilibili.community.service.dm.v1.DanmakuFlag.dmid', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='flag', full_name='bilibili.community.service.dm.v1.DanmakuFlag.flag', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=721, + serialized_end=762, +) + + +_DANMAKUFLAGCONFIG = _descriptor.Descriptor( + name='DanmakuFlagConfig', + full_name='bilibili.community.service.dm.v1.DanmakuFlagConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='rec_flag', full_name='bilibili.community.service.dm.v1.DanmakuFlagConfig.rec_flag', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='rec_text', full_name='bilibili.community.service.dm.v1.DanmakuFlagConfig.rec_text', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='rec_switch', full_name='bilibili.community.service.dm.v1.DanmakuFlagConfig.rec_switch', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=764, + serialized_end=839, +) + + +_DANMUDEFAULTPLAYERCONFIG = _descriptor.Descriptor( + name='DanmuDefaultPlayerConfig', + full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='player_danmaku_use_default_config', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_use_default_config', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_ai_recommended_switch', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_ai_recommended_switch', index=1, + number=4, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_ai_recommended_level', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_ai_recommended_level', index=2, + number=5, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blocktop', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_blocktop', index=3, + number=6, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockscroll', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_blockscroll', index=4, + number=7, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockbottom', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_blockbottom', index=5, + number=8, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockcolorful', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_blockcolorful', index=6, + number=9, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockrepeat', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_blockrepeat', index=7, + number=10, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockspecial', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_blockspecial', index=8, + number=11, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_opacity', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_opacity', index=9, + number=12, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_scalingfactor', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_scalingfactor', index=10, + number=13, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_domain', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_domain', index=11, + number=14, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_speed', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_speed', index=12, + number=15, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='inline_player_danmaku_switch', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.inline_player_danmaku_switch', index=13, + number=16, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_senior_mode_switch', full_name='bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig.player_danmaku_senior_mode_switch', index=14, + number=17, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=842, + serialized_end=1430, +) + + +_DANMUPLAYERCONFIG = _descriptor.Descriptor( + name='DanmuPlayerConfig', + full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='player_danmaku_switch', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_switch', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_switch_save', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_switch_save', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_use_default_config', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_use_default_config', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_ai_recommended_switch', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_ai_recommended_switch', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_ai_recommended_level', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_ai_recommended_level', index=4, + number=5, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blocktop', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_blocktop', index=5, + number=6, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockscroll', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_blockscroll', index=6, + number=7, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockbottom', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_blockbottom', index=7, + number=8, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockcolorful', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_blockcolorful', index=8, + number=9, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockrepeat', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_blockrepeat', index=9, + number=10, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_blockspecial', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_blockspecial', index=10, + number=11, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_opacity', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_opacity', index=11, + number=12, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_scalingfactor', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_scalingfactor', index=12, + number=13, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_domain', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_domain', index=13, + number=14, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_speed', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_speed', index=14, + number=15, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_enableblocklist', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_enableblocklist', index=15, + number=16, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='inline_player_danmaku_switch', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.inline_player_danmaku_switch', index=16, + number=17, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='inline_player_danmaku_config', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.inline_player_danmaku_config', index=17, + number=18, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_ios_switch_save', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_ios_switch_save', index=18, + number=19, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_senior_mode_switch', full_name='bilibili.community.service.dm.v1.DanmuPlayerConfig.player_danmaku_senior_mode_switch', index=19, + number=20, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1433, + serialized_end=2199, +) + + +_DANMUPLAYERDYNAMICCONFIG = _descriptor.Descriptor( + name='DanmuPlayerDynamicConfig', + full_name='bilibili.community.service.dm.v1.DanmuPlayerDynamicConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='progress', full_name='bilibili.community.service.dm.v1.DanmuPlayerDynamicConfig.progress', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_danmaku_domain', full_name='bilibili.community.service.dm.v1.DanmuPlayerDynamicConfig.player_danmaku_domain', index=1, + number=14, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2201, + serialized_end=2276, +) + + +_DANMUPLAYERVIEWCONFIG = _descriptor.Descriptor( + name='DanmuPlayerViewConfig', + full_name='bilibili.community.service.dm.v1.DanmuPlayerViewConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='danmuku_default_player_config', full_name='bilibili.community.service.dm.v1.DanmuPlayerViewConfig.danmuku_default_player_config', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='danmuku_player_config', full_name='bilibili.community.service.dm.v1.DanmuPlayerViewConfig.danmuku_player_config', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='danmuku_player_dynamic_config', full_name='bilibili.community.service.dm.v1.DanmuPlayerViewConfig.danmuku_player_dynamic_config', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2279, + serialized_end=2584, +) + + +_DANMUWEBPLAYERCONFIG = _descriptor.Descriptor( + name='DanmuWebPlayerConfig', + full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='dm_switch', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.dm_switch', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ai_switch', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.ai_switch', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ai_level', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.ai_level', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blocktop', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.blocktop', index=3, + number=4, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockscroll', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.blockscroll', index=4, + number=5, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockbottom', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.blockbottom', index=5, + number=6, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockcolor', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.blockcolor', index=6, + number=7, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockspecial', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.blockspecial', index=7, + number=8, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='preventshade', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.preventshade', index=8, + number=9, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='dmask', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.dmask', index=9, + number=10, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='opacity', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.opacity', index=10, + number=11, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='dmarea', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.dmarea', index=11, + number=12, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='speedplus', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.speedplus', index=12, + number=13, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='fontsize', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.fontsize', index=13, + number=14, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='screensync', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.screensync', index=14, + number=15, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='speedsync', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.speedsync', index=15, + number=16, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='fontfamily', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.fontfamily', index=16, + number=17, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='bold', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.bold', index=17, + number=18, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='fontborder', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.fontborder', index=18, + number=19, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='draw_type', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.draw_type', index=19, + number=20, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='senior_mode_switch', full_name='bilibili.community.service.dm.v1.DanmuWebPlayerConfig.senior_mode_switch', index=20, + number=21, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2587, + serialized_end=3014, +) + + +_DMEXPOREPORTREQ = _descriptor.Descriptor( + name='DmExpoReportReq', + full_name='bilibili.community.service.dm.v1.DmExpoReportReq', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='session_id', full_name='bilibili.community.service.dm.v1.DmExpoReportReq.session_id', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oid', full_name='bilibili.community.service.dm.v1.DmExpoReportReq.oid', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='spmid', full_name='bilibili.community.service.dm.v1.DmExpoReportReq.spmid', index=2, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3016, + serialized_end=3081, +) + + +_DMEXPOREPORTRES = _descriptor.Descriptor( + name='DmExpoReportRes', + full_name='bilibili.community.service.dm.v1.DmExpoReportRes', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3083, + serialized_end=3100, +) + + +_DMPLAYERCONFIGREQ = _descriptor.Descriptor( + name='DmPlayerConfigReq', + full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='ts', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.ts', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='switch', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.switch', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='switch_save', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.switch_save', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='use_default_config', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.use_default_config', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ai_recommended_switch', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.ai_recommended_switch', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ai_recommended_level', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.ai_recommended_level', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blocktop', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.blocktop', index=6, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockscroll', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.blockscroll', index=7, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockbottom', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.blockbottom', index=8, + number=9, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockcolorful', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.blockcolorful', index=9, + number=10, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockrepeat', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.blockrepeat', index=10, + number=11, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='blockspecial', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.blockspecial', index=11, + number=12, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='opacity', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.opacity', index=12, + number=13, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='scalingfactor', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.scalingfactor', index=13, + number=14, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='domain', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.domain', index=14, + number=15, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='speed', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.speed', index=15, + number=16, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='enableblocklist', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.enableblocklist', index=16, + number=17, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='inlinePlayerDanmakuSwitch', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.inlinePlayerDanmakuSwitch', index=17, + number=18, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='senior_mode_switch', full_name='bilibili.community.service.dm.v1.DmPlayerConfigReq.senior_mode_switch', index=18, + number=19, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3103, + serialized_end=4636, +) + + +_DMSEGCONFIG = _descriptor.Descriptor( + name='DmSegConfig', + full_name='bilibili.community.service.dm.v1.DmSegConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='page_size', full_name='bilibili.community.service.dm.v1.DmSegConfig.page_size', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='total', full_name='bilibili.community.service.dm.v1.DmSegConfig.total', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4638, + serialized_end=4685, +) + + +_DMSEGMOBILEREPLY = _descriptor.Descriptor( + name='DmSegMobileReply', + full_name='bilibili.community.service.dm.v1.DmSegMobileReply', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='elems', full_name='bilibili.community.service.dm.v1.DmSegMobileReply.elems', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='state', full_name='bilibili.community.service.dm.v1.DmSegMobileReply.state', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ai_flag', full_name='bilibili.community.service.dm.v1.DmSegMobileReply.ai_flag', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4688, + serialized_end=4849, +) + + +_DMSEGMOBILEREQ = _descriptor.Descriptor( + name='DmSegMobileReq', + full_name='bilibili.community.service.dm.v1.DmSegMobileReq', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='pid', full_name='bilibili.community.service.dm.v1.DmSegMobileReq.pid', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oid', full_name='bilibili.community.service.dm.v1.DmSegMobileReq.oid', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type', full_name='bilibili.community.service.dm.v1.DmSegMobileReq.type', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='segment_index', full_name='bilibili.community.service.dm.v1.DmSegMobileReq.segment_index', index=3, + number=4, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='teenagers_mode', full_name='bilibili.community.service.dm.v1.DmSegMobileReq.teenagers_mode', index=4, + number=5, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4851, + serialized_end=4954, +) + + +_DMSEGOTTREPLY = _descriptor.Descriptor( + name='DmSegOttReply', + full_name='bilibili.community.service.dm.v1.DmSegOttReply', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='closed', full_name='bilibili.community.service.dm.v1.DmSegOttReply.closed', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='elems', full_name='bilibili.community.service.dm.v1.DmSegOttReply.elems', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=4956, + serialized_end=5049, +) + + +_DMSEGOTTREQ = _descriptor.Descriptor( + name='DmSegOttReq', + full_name='bilibili.community.service.dm.v1.DmSegOttReq', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='pid', full_name='bilibili.community.service.dm.v1.DmSegOttReq.pid', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oid', full_name='bilibili.community.service.dm.v1.DmSegOttReq.oid', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type', full_name='bilibili.community.service.dm.v1.DmSegOttReq.type', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='segment_index', full_name='bilibili.community.service.dm.v1.DmSegOttReq.segment_index', index=3, + number=4, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5051, + serialized_end=5127, +) + + +_DMSEGSDKREPLY = _descriptor.Descriptor( + name='DmSegSDKReply', + full_name='bilibili.community.service.dm.v1.DmSegSDKReply', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='closed', full_name='bilibili.community.service.dm.v1.DmSegSDKReply.closed', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='elems', full_name='bilibili.community.service.dm.v1.DmSegSDKReply.elems', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5129, + serialized_end=5222, +) + + +_DMSEGSDKREQ = _descriptor.Descriptor( + name='DmSegSDKReq', + full_name='bilibili.community.service.dm.v1.DmSegSDKReq', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='pid', full_name='bilibili.community.service.dm.v1.DmSegSDKReq.pid', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oid', full_name='bilibili.community.service.dm.v1.DmSegSDKReq.oid', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type', full_name='bilibili.community.service.dm.v1.DmSegSDKReq.type', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='segment_index', full_name='bilibili.community.service.dm.v1.DmSegSDKReq.segment_index', index=3, + number=4, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5224, + serialized_end=5300, +) + + +_DMVIEWREPLY = _descriptor.Descriptor( + name='DmViewReply', + full_name='bilibili.community.service.dm.v1.DmViewReply', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='closed', full_name='bilibili.community.service.dm.v1.DmViewReply.closed', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='mask', full_name='bilibili.community.service.dm.v1.DmViewReply.mask', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='subtitle', full_name='bilibili.community.service.dm.v1.DmViewReply.subtitle', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='special_dms', full_name='bilibili.community.service.dm.v1.DmViewReply.special_dms', index=3, + number=4, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ai_flag', full_name='bilibili.community.service.dm.v1.DmViewReply.ai_flag', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_config', full_name='bilibili.community.service.dm.v1.DmViewReply.player_config', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='send_box_style', full_name='bilibili.community.service.dm.v1.DmViewReply.send_box_style', index=6, + number=7, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='allow', full_name='bilibili.community.service.dm.v1.DmViewReply.allow', index=7, + number=8, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='check_box', full_name='bilibili.community.service.dm.v1.DmViewReply.check_box', index=8, + number=9, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='check_box_show_msg', full_name='bilibili.community.service.dm.v1.DmViewReply.check_box_show_msg', index=9, + number=10, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='text_placeholder', full_name='bilibili.community.service.dm.v1.DmViewReply.text_placeholder', index=10, + number=11, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='input_placeholder', full_name='bilibili.community.service.dm.v1.DmViewReply.input_placeholder', index=11, + number=12, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='report_filter_content', full_name='bilibili.community.service.dm.v1.DmViewReply.report_filter_content', index=12, + number=13, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='expo_report', full_name='bilibili.community.service.dm.v1.DmViewReply.expo_report', index=13, + number=14, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='buzzword_config', full_name='bilibili.community.service.dm.v1.DmViewReply.buzzword_config', index=14, + number=15, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='expressions', full_name='bilibili.community.service.dm.v1.DmViewReply.expressions', index=15, + number=16, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=5303, + serialized_end=6009, +) + + +_DMVIEWREQ = _descriptor.Descriptor( + name='DmViewReq', + full_name='bilibili.community.service.dm.v1.DmViewReq', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='pid', full_name='bilibili.community.service.dm.v1.DmViewReq.pid', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oid', full_name='bilibili.community.service.dm.v1.DmViewReq.oid', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type', full_name='bilibili.community.service.dm.v1.DmViewReq.type', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='spmid', full_name='bilibili.community.service.dm.v1.DmViewReq.spmid', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='is_hard_boot', full_name='bilibili.community.service.dm.v1.DmViewReq.is_hard_boot', index=4, + number=5, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6011, + serialized_end=6099, +) + + +_DMWEBVIEWREPLY = _descriptor.Descriptor( + name='DmWebViewReply', + full_name='bilibili.community.service.dm.v1.DmWebViewReply', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='state', full_name='bilibili.community.service.dm.v1.DmWebViewReply.state', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='text', full_name='bilibili.community.service.dm.v1.DmWebViewReply.text', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='text_side', full_name='bilibili.community.service.dm.v1.DmWebViewReply.text_side', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='dm_sge', full_name='bilibili.community.service.dm.v1.DmWebViewReply.dm_sge', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='flag', full_name='bilibili.community.service.dm.v1.DmWebViewReply.flag', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='special_dms', full_name='bilibili.community.service.dm.v1.DmWebViewReply.special_dms', index=5, + number=6, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='check_box', full_name='bilibili.community.service.dm.v1.DmWebViewReply.check_box', index=6, + number=7, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='count', full_name='bilibili.community.service.dm.v1.DmWebViewReply.count', index=7, + number=8, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='commandDms', full_name='bilibili.community.service.dm.v1.DmWebViewReply.commandDms', index=8, + number=9, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='player_config', full_name='bilibili.community.service.dm.v1.DmWebViewReply.player_config', index=9, + number=10, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='report_filter_content', full_name='bilibili.community.service.dm.v1.DmWebViewReply.report_filter_content', index=10, + number=11, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='expressions', full_name='bilibili.community.service.dm.v1.DmWebViewReply.expressions', index=11, + number=12, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6102, + serialized_end=6594, +) + + +_EXPOREPORT = _descriptor.Descriptor( + name='ExpoReport', + full_name='bilibili.community.service.dm.v1.ExpoReport', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='should_report_at_end', full_name='bilibili.community.service.dm.v1.ExpoReport.should_report_at_end', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6596, + serialized_end=6638, +) + + +_EXPRESSION = _descriptor.Descriptor( + name='Expression', + full_name='bilibili.community.service.dm.v1.Expression', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='keyword', full_name='bilibili.community.service.dm.v1.Expression.keyword', index=0, + number=1, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='url', full_name='bilibili.community.service.dm.v1.Expression.url', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='period', full_name='bilibili.community.service.dm.v1.Expression.period', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6640, + serialized_end=6740, +) + + +_EXPRESSIONS = _descriptor.Descriptor( + name='Expressions', + full_name='bilibili.community.service.dm.v1.Expressions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='data', full_name='bilibili.community.service.dm.v1.Expressions.data', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6742, + serialized_end=6815, +) + + +_PERIOD = _descriptor.Descriptor( + name='Period', + full_name='bilibili.community.service.dm.v1.Period', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='start', full_name='bilibili.community.service.dm.v1.Period.start', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='end', full_name='bilibili.community.service.dm.v1.Period.end', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6817, + serialized_end=6853, +) + + +_INLINEPLAYERDANMAKUSWITCH = _descriptor.Descriptor( + name='InlinePlayerDanmakuSwitch', + full_name='bilibili.community.service.dm.v1.InlinePlayerDanmakuSwitch', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.InlinePlayerDanmakuSwitch.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6855, + serialized_end=6897, +) + + +_PLAYERDANMAKUAIRECOMMENDEDLEVEL = _descriptor.Descriptor( + name='PlayerDanmakuAiRecommendedLevel', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedLevel', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedLevel.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6899, + serialized_end=6947, +) + + +_PLAYERDANMAKUAIRECOMMENDEDSWITCH = _descriptor.Descriptor( + name='PlayerDanmakuAiRecommendedSwitch', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedSwitch', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedSwitch.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=6949, + serialized_end=6998, +) + + +_PLAYERDANMAKUBLOCKBOTTOM = _descriptor.Descriptor( + name='PlayerDanmakuBlockbottom', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockbottom', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockbottom.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7000, + serialized_end=7041, +) + + +_PLAYERDANMAKUBLOCKCOLORFUL = _descriptor.Descriptor( + name='PlayerDanmakuBlockcolorful', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockcolorful', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockcolorful.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7043, + serialized_end=7086, +) + + +_PLAYERDANMAKUBLOCKREPEAT = _descriptor.Descriptor( + name='PlayerDanmakuBlockrepeat', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockrepeat', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockrepeat.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7088, + serialized_end=7129, +) + + +_PLAYERDANMAKUBLOCKSCROLL = _descriptor.Descriptor( + name='PlayerDanmakuBlockscroll', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockscroll', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockscroll.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7131, + serialized_end=7172, +) + + +_PLAYERDANMAKUBLOCKSPECIAL = _descriptor.Descriptor( + name='PlayerDanmakuBlockspecial', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockspecial', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlockspecial.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7174, + serialized_end=7216, +) + + +_PLAYERDANMAKUBLOCKTOP = _descriptor.Descriptor( + name='PlayerDanmakuBlocktop', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlocktop', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuBlocktop.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7218, + serialized_end=7256, +) + + +_PLAYERDANMAKUDOMAIN = _descriptor.Descriptor( + name='PlayerDanmakuDomain', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuDomain', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuDomain.value', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7258, + serialized_end=7294, +) + + +_PLAYERDANMAKUENABLEBLOCKLIST = _descriptor.Descriptor( + name='PlayerDanmakuEnableblocklist', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuEnableblocklist', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuEnableblocklist.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7296, + serialized_end=7341, +) + + +_PLAYERDANMAKUOPACITY = _descriptor.Descriptor( + name='PlayerDanmakuOpacity', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuOpacity', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuOpacity.value', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7343, + serialized_end=7380, +) + + +_PLAYERDANMAKUSCALINGFACTOR = _descriptor.Descriptor( + name='PlayerDanmakuScalingfactor', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuScalingfactor', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuScalingfactor.value', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7382, + serialized_end=7425, +) + + +_PLAYERDANMAKUSENIORMODESWITCH = _descriptor.Descriptor( + name='PlayerDanmakuSeniorModeSwitch', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuSeniorModeSwitch', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuSeniorModeSwitch.value', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7427, + serialized_end=7473, +) + + +_PLAYERDANMAKUSPEED = _descriptor.Descriptor( + name='PlayerDanmakuSpeed', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuSpeed', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuSpeed.value', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7475, + serialized_end=7510, +) + + +_PLAYERDANMAKUSWITCH = _descriptor.Descriptor( + name='PlayerDanmakuSwitch', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuSwitch', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuSwitch.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='canIgnore', full_name='bilibili.community.service.dm.v1.PlayerDanmakuSwitch.canIgnore', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7512, + serialized_end=7567, +) + + +_PLAYERDANMAKUSWITCHSAVE = _descriptor.Descriptor( + name='PlayerDanmakuSwitchSave', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuSwitchSave', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuSwitchSave.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7569, + serialized_end=7609, +) + + +_PLAYERDANMAKUUSEDEFAULTCONFIG = _descriptor.Descriptor( + name='PlayerDanmakuUseDefaultConfig', + full_name='bilibili.community.service.dm.v1.PlayerDanmakuUseDefaultConfig', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='bilibili.community.service.dm.v1.PlayerDanmakuUseDefaultConfig.value', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7611, + serialized_end=7657, +) + + +_RESPONSE = _descriptor.Descriptor( + name='Response', + full_name='bilibili.community.service.dm.v1.Response', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='code', full_name='bilibili.community.service.dm.v1.Response.code', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='message', full_name='bilibili.community.service.dm.v1.Response.message', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7659, + serialized_end=7700, +) + + +_SUBTITLEITEM = _descriptor.Descriptor( + name='SubtitleItem', + full_name='bilibili.community.service.dm.v1.SubtitleItem', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='id', full_name='bilibili.community.service.dm.v1.SubtitleItem.id', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='id_str', full_name='bilibili.community.service.dm.v1.SubtitleItem.id_str', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='lan', full_name='bilibili.community.service.dm.v1.SubtitleItem.lan', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='lan_doc', full_name='bilibili.community.service.dm.v1.SubtitleItem.lan_doc', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='subtitle_url', full_name='bilibili.community.service.dm.v1.SubtitleItem.subtitle_url', index=4, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='author', full_name='bilibili.community.service.dm.v1.SubtitleItem.author', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type', full_name='bilibili.community.service.dm.v1.SubtitleItem.type', index=6, + number=7, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7703, + serialized_end=7919, +) + + +_USERINFO = _descriptor.Descriptor( + name='UserInfo', + full_name='bilibili.community.service.dm.v1.UserInfo', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='mid', full_name='bilibili.community.service.dm.v1.UserInfo.mid', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='name', full_name='bilibili.community.service.dm.v1.UserInfo.name', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='sex', full_name='bilibili.community.service.dm.v1.UserInfo.sex', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='face', full_name='bilibili.community.service.dm.v1.UserInfo.face', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='sign', full_name='bilibili.community.service.dm.v1.UserInfo.sign', index=4, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='rank', full_name='bilibili.community.service.dm.v1.UserInfo.rank', index=5, + number=6, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=7921, + serialized_end=8013, +) + + +_VIDEOMASK = _descriptor.Descriptor( + name='VideoMask', + full_name='bilibili.community.service.dm.v1.VideoMask', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='cid', full_name='bilibili.community.service.dm.v1.VideoMask.cid', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='plat', full_name='bilibili.community.service.dm.v1.VideoMask.plat', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='fps', full_name='bilibili.community.service.dm.v1.VideoMask.fps', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='time', full_name='bilibili.community.service.dm.v1.VideoMask.time', index=3, + number=4, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='mask_url', full_name='bilibili.community.service.dm.v1.VideoMask.mask_url', index=4, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=8015, + serialized_end=8098, +) + + +_VIDEOSUBTITLE = _descriptor.Descriptor( + name='VideoSubtitle', + full_name='bilibili.community.service.dm.v1.VideoSubtitle', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='lan', full_name='bilibili.community.service.dm.v1.VideoSubtitle.lan', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='lanDoc', full_name='bilibili.community.service.dm.v1.VideoSubtitle.lanDoc', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='subtitles', full_name='bilibili.community.service.dm.v1.VideoSubtitle.subtitles', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=8100, + serialized_end=8211, +) + +_BUZZWORDCONFIG.fields_by_name['keywords'].message_type = _BUZZWORDSHOWCONFIG +_DANMAKUAIFLAG.fields_by_name['dm_flags'].message_type = _DANMAKUFLAG +_DANMUPLAYERVIEWCONFIG.fields_by_name['danmuku_default_player_config'].message_type = _DANMUDEFAULTPLAYERCONFIG +_DANMUPLAYERVIEWCONFIG.fields_by_name['danmuku_player_config'].message_type = _DANMUPLAYERCONFIG +_DANMUPLAYERVIEWCONFIG.fields_by_name['danmuku_player_dynamic_config'].message_type = _DANMUPLAYERDYNAMICCONFIG +_DMPLAYERCONFIGREQ.fields_by_name['switch'].message_type = _PLAYERDANMAKUSWITCH +_DMPLAYERCONFIGREQ.fields_by_name['switch_save'].message_type = _PLAYERDANMAKUSWITCHSAVE +_DMPLAYERCONFIGREQ.fields_by_name['use_default_config'].message_type = _PLAYERDANMAKUUSEDEFAULTCONFIG +_DMPLAYERCONFIGREQ.fields_by_name['ai_recommended_switch'].message_type = _PLAYERDANMAKUAIRECOMMENDEDSWITCH +_DMPLAYERCONFIGREQ.fields_by_name['ai_recommended_level'].message_type = _PLAYERDANMAKUAIRECOMMENDEDLEVEL +_DMPLAYERCONFIGREQ.fields_by_name['blocktop'].message_type = _PLAYERDANMAKUBLOCKTOP +_DMPLAYERCONFIGREQ.fields_by_name['blockscroll'].message_type = _PLAYERDANMAKUBLOCKSCROLL +_DMPLAYERCONFIGREQ.fields_by_name['blockbottom'].message_type = _PLAYERDANMAKUBLOCKBOTTOM +_DMPLAYERCONFIGREQ.fields_by_name['blockcolorful'].message_type = _PLAYERDANMAKUBLOCKCOLORFUL +_DMPLAYERCONFIGREQ.fields_by_name['blockrepeat'].message_type = _PLAYERDANMAKUBLOCKREPEAT +_DMPLAYERCONFIGREQ.fields_by_name['blockspecial'].message_type = _PLAYERDANMAKUBLOCKSPECIAL +_DMPLAYERCONFIGREQ.fields_by_name['opacity'].message_type = _PLAYERDANMAKUOPACITY +_DMPLAYERCONFIGREQ.fields_by_name['scalingfactor'].message_type = _PLAYERDANMAKUSCALINGFACTOR +_DMPLAYERCONFIGREQ.fields_by_name['domain'].message_type = _PLAYERDANMAKUDOMAIN +_DMPLAYERCONFIGREQ.fields_by_name['speed'].message_type = _PLAYERDANMAKUSPEED +_DMPLAYERCONFIGREQ.fields_by_name['enableblocklist'].message_type = _PLAYERDANMAKUENABLEBLOCKLIST +_DMPLAYERCONFIGREQ.fields_by_name['inlinePlayerDanmakuSwitch'].message_type = _INLINEPLAYERDANMAKUSWITCH +_DMPLAYERCONFIGREQ.fields_by_name['senior_mode_switch'].message_type = _PLAYERDANMAKUSENIORMODESWITCH +_DMSEGMOBILEREPLY.fields_by_name['elems'].message_type = _DANMAKUELEM +_DMSEGMOBILEREPLY.fields_by_name['ai_flag'].message_type = _DANMAKUAIFLAG +_DMSEGOTTREPLY.fields_by_name['elems'].message_type = _DANMAKUELEM +_DMSEGSDKREPLY.fields_by_name['elems'].message_type = _DANMAKUELEM +_DMVIEWREPLY.fields_by_name['mask'].message_type = _VIDEOMASK +_DMVIEWREPLY.fields_by_name['subtitle'].message_type = _VIDEOSUBTITLE +_DMVIEWREPLY.fields_by_name['ai_flag'].message_type = _DANMAKUFLAGCONFIG +_DMVIEWREPLY.fields_by_name['player_config'].message_type = _DANMUPLAYERVIEWCONFIG +_DMVIEWREPLY.fields_by_name['expo_report'].message_type = _EXPOREPORT +_DMVIEWREPLY.fields_by_name['buzzword_config'].message_type = _BUZZWORDCONFIG +_DMVIEWREPLY.fields_by_name['expressions'].message_type = _EXPRESSIONS +_DMWEBVIEWREPLY.fields_by_name['dm_sge'].message_type = _DMSEGCONFIG +_DMWEBVIEWREPLY.fields_by_name['flag'].message_type = _DANMAKUFLAGCONFIG +_DMWEBVIEWREPLY.fields_by_name['commandDms'].message_type = _COMMANDDM +_DMWEBVIEWREPLY.fields_by_name['player_config'].message_type = _DANMUWEBPLAYERCONFIG +_DMWEBVIEWREPLY.fields_by_name['expressions'].message_type = _EXPRESSIONS +_EXPRESSION.fields_by_name['period'].message_type = _PERIOD +_EXPRESSIONS.fields_by_name['data'].message_type = _EXPRESSION +_SUBTITLEITEM.fields_by_name['author'].message_type = _USERINFO +_SUBTITLEITEM.fields_by_name['type'].enum_type = _SUBTITLETYPE +_VIDEOSUBTITLE.fields_by_name['subtitles'].message_type = _SUBTITLEITEM +DESCRIPTOR.message_types_by_name['BuzzwordConfig'] = _BUZZWORDCONFIG +DESCRIPTOR.message_types_by_name['BuzzwordShowConfig'] = _BUZZWORDSHOWCONFIG +DESCRIPTOR.message_types_by_name['CommandDm'] = _COMMANDDM +DESCRIPTOR.message_types_by_name['DanmakuAIFlag'] = _DANMAKUAIFLAG +DESCRIPTOR.message_types_by_name['DanmakuElem'] = _DANMAKUELEM +DESCRIPTOR.message_types_by_name['DanmakuFlag'] = _DANMAKUFLAG +DESCRIPTOR.message_types_by_name['DanmakuFlagConfig'] = _DANMAKUFLAGCONFIG +DESCRIPTOR.message_types_by_name['DanmuDefaultPlayerConfig'] = _DANMUDEFAULTPLAYERCONFIG +DESCRIPTOR.message_types_by_name['DanmuPlayerConfig'] = _DANMUPLAYERCONFIG +DESCRIPTOR.message_types_by_name['DanmuPlayerDynamicConfig'] = _DANMUPLAYERDYNAMICCONFIG +DESCRIPTOR.message_types_by_name['DanmuPlayerViewConfig'] = _DANMUPLAYERVIEWCONFIG +DESCRIPTOR.message_types_by_name['DanmuWebPlayerConfig'] = _DANMUWEBPLAYERCONFIG +DESCRIPTOR.message_types_by_name['DmExpoReportReq'] = _DMEXPOREPORTREQ +DESCRIPTOR.message_types_by_name['DmExpoReportRes'] = _DMEXPOREPORTRES +DESCRIPTOR.message_types_by_name['DmPlayerConfigReq'] = _DMPLAYERCONFIGREQ +DESCRIPTOR.message_types_by_name['DmSegConfig'] = _DMSEGCONFIG +DESCRIPTOR.message_types_by_name['DmSegMobileReply'] = _DMSEGMOBILEREPLY +DESCRIPTOR.message_types_by_name['DmSegMobileReq'] = _DMSEGMOBILEREQ +DESCRIPTOR.message_types_by_name['DmSegOttReply'] = _DMSEGOTTREPLY +DESCRIPTOR.message_types_by_name['DmSegOttReq'] = _DMSEGOTTREQ +DESCRIPTOR.message_types_by_name['DmSegSDKReply'] = _DMSEGSDKREPLY +DESCRIPTOR.message_types_by_name['DmSegSDKReq'] = _DMSEGSDKREQ +DESCRIPTOR.message_types_by_name['DmViewReply'] = _DMVIEWREPLY +DESCRIPTOR.message_types_by_name['DmViewReq'] = _DMVIEWREQ +DESCRIPTOR.message_types_by_name['DmWebViewReply'] = _DMWEBVIEWREPLY +DESCRIPTOR.message_types_by_name['ExpoReport'] = _EXPOREPORT +DESCRIPTOR.message_types_by_name['Expression'] = _EXPRESSION +DESCRIPTOR.message_types_by_name['Expressions'] = _EXPRESSIONS +DESCRIPTOR.message_types_by_name['Period'] = _PERIOD +DESCRIPTOR.message_types_by_name['InlinePlayerDanmakuSwitch'] = _INLINEPLAYERDANMAKUSWITCH +DESCRIPTOR.message_types_by_name['PlayerDanmakuAiRecommendedLevel'] = _PLAYERDANMAKUAIRECOMMENDEDLEVEL +DESCRIPTOR.message_types_by_name['PlayerDanmakuAiRecommendedSwitch'] = _PLAYERDANMAKUAIRECOMMENDEDSWITCH +DESCRIPTOR.message_types_by_name['PlayerDanmakuBlockbottom'] = _PLAYERDANMAKUBLOCKBOTTOM +DESCRIPTOR.message_types_by_name['PlayerDanmakuBlockcolorful'] = _PLAYERDANMAKUBLOCKCOLORFUL +DESCRIPTOR.message_types_by_name['PlayerDanmakuBlockrepeat'] = _PLAYERDANMAKUBLOCKREPEAT +DESCRIPTOR.message_types_by_name['PlayerDanmakuBlockscroll'] = _PLAYERDANMAKUBLOCKSCROLL +DESCRIPTOR.message_types_by_name['PlayerDanmakuBlockspecial'] = _PLAYERDANMAKUBLOCKSPECIAL +DESCRIPTOR.message_types_by_name['PlayerDanmakuBlocktop'] = _PLAYERDANMAKUBLOCKTOP +DESCRIPTOR.message_types_by_name['PlayerDanmakuDomain'] = _PLAYERDANMAKUDOMAIN +DESCRIPTOR.message_types_by_name['PlayerDanmakuEnableblocklist'] = _PLAYERDANMAKUENABLEBLOCKLIST +DESCRIPTOR.message_types_by_name['PlayerDanmakuOpacity'] = _PLAYERDANMAKUOPACITY +DESCRIPTOR.message_types_by_name['PlayerDanmakuScalingfactor'] = _PLAYERDANMAKUSCALINGFACTOR +DESCRIPTOR.message_types_by_name['PlayerDanmakuSeniorModeSwitch'] = _PLAYERDANMAKUSENIORMODESWITCH +DESCRIPTOR.message_types_by_name['PlayerDanmakuSpeed'] = _PLAYERDANMAKUSPEED +DESCRIPTOR.message_types_by_name['PlayerDanmakuSwitch'] = _PLAYERDANMAKUSWITCH +DESCRIPTOR.message_types_by_name['PlayerDanmakuSwitchSave'] = _PLAYERDANMAKUSWITCHSAVE +DESCRIPTOR.message_types_by_name['PlayerDanmakuUseDefaultConfig'] = _PLAYERDANMAKUUSEDEFAULTCONFIG +DESCRIPTOR.message_types_by_name['Response'] = _RESPONSE +DESCRIPTOR.message_types_by_name['SubtitleItem'] = _SUBTITLEITEM +DESCRIPTOR.message_types_by_name['UserInfo'] = _USERINFO +DESCRIPTOR.message_types_by_name['VideoMask'] = _VIDEOMASK +DESCRIPTOR.message_types_by_name['VideoSubtitle'] = _VIDEOSUBTITLE +DESCRIPTOR.enum_types_by_name['DMAttrBit'] = _DMATTRBIT +DESCRIPTOR.enum_types_by_name['SubtitleType'] = _SUBTITLETYPE +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +BuzzwordConfig = _reflection.GeneratedProtocolMessageType('BuzzwordConfig', (_message.Message,), { + 'DESCRIPTOR' : _BUZZWORDCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.BuzzwordConfig) + }) +_sym_db.RegisterMessage(BuzzwordConfig) + +BuzzwordShowConfig = _reflection.GeneratedProtocolMessageType('BuzzwordShowConfig', (_message.Message,), { + 'DESCRIPTOR' : _BUZZWORDSHOWCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.BuzzwordShowConfig) + }) +_sym_db.RegisterMessage(BuzzwordShowConfig) + +CommandDm = _reflection.GeneratedProtocolMessageType('CommandDm', (_message.Message,), { + 'DESCRIPTOR' : _COMMANDDM, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.CommandDm) + }) +_sym_db.RegisterMessage(CommandDm) + +DanmakuAIFlag = _reflection.GeneratedProtocolMessageType('DanmakuAIFlag', (_message.Message,), { + 'DESCRIPTOR' : _DANMAKUAIFLAG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmakuAIFlag) + }) +_sym_db.RegisterMessage(DanmakuAIFlag) + +DanmakuElem = _reflection.GeneratedProtocolMessageType('DanmakuElem', (_message.Message,), { + 'DESCRIPTOR' : _DANMAKUELEM, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmakuElem) + }) +_sym_db.RegisterMessage(DanmakuElem) + +DanmakuFlag = _reflection.GeneratedProtocolMessageType('DanmakuFlag', (_message.Message,), { + 'DESCRIPTOR' : _DANMAKUFLAG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmakuFlag) + }) +_sym_db.RegisterMessage(DanmakuFlag) + +DanmakuFlagConfig = _reflection.GeneratedProtocolMessageType('DanmakuFlagConfig', (_message.Message,), { + 'DESCRIPTOR' : _DANMAKUFLAGCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmakuFlagConfig) + }) +_sym_db.RegisterMessage(DanmakuFlagConfig) + +DanmuDefaultPlayerConfig = _reflection.GeneratedProtocolMessageType('DanmuDefaultPlayerConfig', (_message.Message,), { + 'DESCRIPTOR' : _DANMUDEFAULTPLAYERCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmuDefaultPlayerConfig) + }) +_sym_db.RegisterMessage(DanmuDefaultPlayerConfig) + +DanmuPlayerConfig = _reflection.GeneratedProtocolMessageType('DanmuPlayerConfig', (_message.Message,), { + 'DESCRIPTOR' : _DANMUPLAYERCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmuPlayerConfig) + }) +_sym_db.RegisterMessage(DanmuPlayerConfig) + +DanmuPlayerDynamicConfig = _reflection.GeneratedProtocolMessageType('DanmuPlayerDynamicConfig', (_message.Message,), { + 'DESCRIPTOR' : _DANMUPLAYERDYNAMICCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmuPlayerDynamicConfig) + }) +_sym_db.RegisterMessage(DanmuPlayerDynamicConfig) + +DanmuPlayerViewConfig = _reflection.GeneratedProtocolMessageType('DanmuPlayerViewConfig', (_message.Message,), { + 'DESCRIPTOR' : _DANMUPLAYERVIEWCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmuPlayerViewConfig) + }) +_sym_db.RegisterMessage(DanmuPlayerViewConfig) + +DanmuWebPlayerConfig = _reflection.GeneratedProtocolMessageType('DanmuWebPlayerConfig', (_message.Message,), { + 'DESCRIPTOR' : _DANMUWEBPLAYERCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DanmuWebPlayerConfig) + }) +_sym_db.RegisterMessage(DanmuWebPlayerConfig) + +DmExpoReportReq = _reflection.GeneratedProtocolMessageType('DmExpoReportReq', (_message.Message,), { + 'DESCRIPTOR' : _DMEXPOREPORTREQ, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmExpoReportReq) + }) +_sym_db.RegisterMessage(DmExpoReportReq) + +DmExpoReportRes = _reflection.GeneratedProtocolMessageType('DmExpoReportRes', (_message.Message,), { + 'DESCRIPTOR' : _DMEXPOREPORTRES, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmExpoReportRes) + }) +_sym_db.RegisterMessage(DmExpoReportRes) + +DmPlayerConfigReq = _reflection.GeneratedProtocolMessageType('DmPlayerConfigReq', (_message.Message,), { + 'DESCRIPTOR' : _DMPLAYERCONFIGREQ, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmPlayerConfigReq) + }) +_sym_db.RegisterMessage(DmPlayerConfigReq) + +DmSegConfig = _reflection.GeneratedProtocolMessageType('DmSegConfig', (_message.Message,), { + 'DESCRIPTOR' : _DMSEGCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmSegConfig) + }) +_sym_db.RegisterMessage(DmSegConfig) + +DmSegMobileReply = _reflection.GeneratedProtocolMessageType('DmSegMobileReply', (_message.Message,), { + 'DESCRIPTOR' : _DMSEGMOBILEREPLY, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmSegMobileReply) + }) +_sym_db.RegisterMessage(DmSegMobileReply) + +DmSegMobileReq = _reflection.GeneratedProtocolMessageType('DmSegMobileReq', (_message.Message,), { + 'DESCRIPTOR' : _DMSEGMOBILEREQ, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmSegMobileReq) + }) +_sym_db.RegisterMessage(DmSegMobileReq) + +DmSegOttReply = _reflection.GeneratedProtocolMessageType('DmSegOttReply', (_message.Message,), { + 'DESCRIPTOR' : _DMSEGOTTREPLY, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmSegOttReply) + }) +_sym_db.RegisterMessage(DmSegOttReply) + +DmSegOttReq = _reflection.GeneratedProtocolMessageType('DmSegOttReq', (_message.Message,), { + 'DESCRIPTOR' : _DMSEGOTTREQ, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmSegOttReq) + }) +_sym_db.RegisterMessage(DmSegOttReq) + +DmSegSDKReply = _reflection.GeneratedProtocolMessageType('DmSegSDKReply', (_message.Message,), { + 'DESCRIPTOR' : _DMSEGSDKREPLY, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmSegSDKReply) + }) +_sym_db.RegisterMessage(DmSegSDKReply) + +DmSegSDKReq = _reflection.GeneratedProtocolMessageType('DmSegSDKReq', (_message.Message,), { + 'DESCRIPTOR' : _DMSEGSDKREQ, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmSegSDKReq) + }) +_sym_db.RegisterMessage(DmSegSDKReq) + +DmViewReply = _reflection.GeneratedProtocolMessageType('DmViewReply', (_message.Message,), { + 'DESCRIPTOR' : _DMVIEWREPLY, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmViewReply) + }) +_sym_db.RegisterMessage(DmViewReply) + +DmViewReq = _reflection.GeneratedProtocolMessageType('DmViewReq', (_message.Message,), { + 'DESCRIPTOR' : _DMVIEWREQ, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmViewReq) + }) +_sym_db.RegisterMessage(DmViewReq) + +DmWebViewReply = _reflection.GeneratedProtocolMessageType('DmWebViewReply', (_message.Message,), { + 'DESCRIPTOR' : _DMWEBVIEWREPLY, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.DmWebViewReply) + }) +_sym_db.RegisterMessage(DmWebViewReply) + +ExpoReport = _reflection.GeneratedProtocolMessageType('ExpoReport', (_message.Message,), { + 'DESCRIPTOR' : _EXPOREPORT, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.ExpoReport) + }) +_sym_db.RegisterMessage(ExpoReport) + +Expression = _reflection.GeneratedProtocolMessageType('Expression', (_message.Message,), { + 'DESCRIPTOR' : _EXPRESSION, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.Expression) + }) +_sym_db.RegisterMessage(Expression) + +Expressions = _reflection.GeneratedProtocolMessageType('Expressions', (_message.Message,), { + 'DESCRIPTOR' : _EXPRESSIONS, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.Expressions) + }) +_sym_db.RegisterMessage(Expressions) + +Period = _reflection.GeneratedProtocolMessageType('Period', (_message.Message,), { + 'DESCRIPTOR' : _PERIOD, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.Period) + }) +_sym_db.RegisterMessage(Period) + +InlinePlayerDanmakuSwitch = _reflection.GeneratedProtocolMessageType('InlinePlayerDanmakuSwitch', (_message.Message,), { + 'DESCRIPTOR' : _INLINEPLAYERDANMAKUSWITCH, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.InlinePlayerDanmakuSwitch) + }) +_sym_db.RegisterMessage(InlinePlayerDanmakuSwitch) + +PlayerDanmakuAiRecommendedLevel = _reflection.GeneratedProtocolMessageType('PlayerDanmakuAiRecommendedLevel', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUAIRECOMMENDEDLEVEL, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedLevel) + }) +_sym_db.RegisterMessage(PlayerDanmakuAiRecommendedLevel) + +PlayerDanmakuAiRecommendedSwitch = _reflection.GeneratedProtocolMessageType('PlayerDanmakuAiRecommendedSwitch', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUAIRECOMMENDEDSWITCH, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuAiRecommendedSwitch) + }) +_sym_db.RegisterMessage(PlayerDanmakuAiRecommendedSwitch) + +PlayerDanmakuBlockbottom = _reflection.GeneratedProtocolMessageType('PlayerDanmakuBlockbottom', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUBLOCKBOTTOM, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuBlockbottom) + }) +_sym_db.RegisterMessage(PlayerDanmakuBlockbottom) + +PlayerDanmakuBlockcolorful = _reflection.GeneratedProtocolMessageType('PlayerDanmakuBlockcolorful', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUBLOCKCOLORFUL, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuBlockcolorful) + }) +_sym_db.RegisterMessage(PlayerDanmakuBlockcolorful) + +PlayerDanmakuBlockrepeat = _reflection.GeneratedProtocolMessageType('PlayerDanmakuBlockrepeat', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUBLOCKREPEAT, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuBlockrepeat) + }) +_sym_db.RegisterMessage(PlayerDanmakuBlockrepeat) + +PlayerDanmakuBlockscroll = _reflection.GeneratedProtocolMessageType('PlayerDanmakuBlockscroll', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUBLOCKSCROLL, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuBlockscroll) + }) +_sym_db.RegisterMessage(PlayerDanmakuBlockscroll) + +PlayerDanmakuBlockspecial = _reflection.GeneratedProtocolMessageType('PlayerDanmakuBlockspecial', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUBLOCKSPECIAL, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuBlockspecial) + }) +_sym_db.RegisterMessage(PlayerDanmakuBlockspecial) + +PlayerDanmakuBlocktop = _reflection.GeneratedProtocolMessageType('PlayerDanmakuBlocktop', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUBLOCKTOP, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuBlocktop) + }) +_sym_db.RegisterMessage(PlayerDanmakuBlocktop) + +PlayerDanmakuDomain = _reflection.GeneratedProtocolMessageType('PlayerDanmakuDomain', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUDOMAIN, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuDomain) + }) +_sym_db.RegisterMessage(PlayerDanmakuDomain) + +PlayerDanmakuEnableblocklist = _reflection.GeneratedProtocolMessageType('PlayerDanmakuEnableblocklist', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUENABLEBLOCKLIST, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuEnableblocklist) + }) +_sym_db.RegisterMessage(PlayerDanmakuEnableblocklist) + +PlayerDanmakuOpacity = _reflection.GeneratedProtocolMessageType('PlayerDanmakuOpacity', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUOPACITY, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuOpacity) + }) +_sym_db.RegisterMessage(PlayerDanmakuOpacity) + +PlayerDanmakuScalingfactor = _reflection.GeneratedProtocolMessageType('PlayerDanmakuScalingfactor', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUSCALINGFACTOR, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuScalingfactor) + }) +_sym_db.RegisterMessage(PlayerDanmakuScalingfactor) + +PlayerDanmakuSeniorModeSwitch = _reflection.GeneratedProtocolMessageType('PlayerDanmakuSeniorModeSwitch', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUSENIORMODESWITCH, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuSeniorModeSwitch) + }) +_sym_db.RegisterMessage(PlayerDanmakuSeniorModeSwitch) + +PlayerDanmakuSpeed = _reflection.GeneratedProtocolMessageType('PlayerDanmakuSpeed', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUSPEED, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuSpeed) + }) +_sym_db.RegisterMessage(PlayerDanmakuSpeed) + +PlayerDanmakuSwitch = _reflection.GeneratedProtocolMessageType('PlayerDanmakuSwitch', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUSWITCH, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuSwitch) + }) +_sym_db.RegisterMessage(PlayerDanmakuSwitch) + +PlayerDanmakuSwitchSave = _reflection.GeneratedProtocolMessageType('PlayerDanmakuSwitchSave', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUSWITCHSAVE, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuSwitchSave) + }) +_sym_db.RegisterMessage(PlayerDanmakuSwitchSave) + +PlayerDanmakuUseDefaultConfig = _reflection.GeneratedProtocolMessageType('PlayerDanmakuUseDefaultConfig', (_message.Message,), { + 'DESCRIPTOR' : _PLAYERDANMAKUUSEDEFAULTCONFIG, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.PlayerDanmakuUseDefaultConfig) + }) +_sym_db.RegisterMessage(PlayerDanmakuUseDefaultConfig) + +Response = _reflection.GeneratedProtocolMessageType('Response', (_message.Message,), { + 'DESCRIPTOR' : _RESPONSE, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.Response) + }) +_sym_db.RegisterMessage(Response) + +SubtitleItem = _reflection.GeneratedProtocolMessageType('SubtitleItem', (_message.Message,), { + 'DESCRIPTOR' : _SUBTITLEITEM, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.SubtitleItem) + }) +_sym_db.RegisterMessage(SubtitleItem) + +UserInfo = _reflection.GeneratedProtocolMessageType('UserInfo', (_message.Message,), { + 'DESCRIPTOR' : _USERINFO, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.UserInfo) + }) +_sym_db.RegisterMessage(UserInfo) + +VideoMask = _reflection.GeneratedProtocolMessageType('VideoMask', (_message.Message,), { + 'DESCRIPTOR' : _VIDEOMASK, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.VideoMask) + }) +_sym_db.RegisterMessage(VideoMask) + +VideoSubtitle = _reflection.GeneratedProtocolMessageType('VideoSubtitle', (_message.Message,), { + 'DESCRIPTOR' : _VIDEOSUBTITLE, + '__module__' : 'my_pb2' + # @@protoc_insertion_point(class_scope:bilibili.community.service.dm.v1.VideoSubtitle) + }) +_sym_db.RegisterMessage(VideoSubtitle) + + + +_DM = _descriptor.ServiceDescriptor( + name='DM', + full_name='bilibili.community.service.dm.v1.DM', + file=DESCRIPTOR, + index=0, + serialized_options=None, + create_key=_descriptor._internal_create_key, + serialized_start=8324, + serialized_end=8996, + methods=[ + _descriptor.MethodDescriptor( + name='DmSegMobile', + full_name='bilibili.community.service.dm.v1.DM.DmSegMobile', + index=0, + containing_service=None, + input_type=_DMSEGMOBILEREQ, + output_type=_DMSEGMOBILEREPLY, + serialized_options=None, + create_key=_descriptor._internal_create_key, + ), + _descriptor.MethodDescriptor( + name='DmView', + full_name='bilibili.community.service.dm.v1.DM.DmView', + index=1, + containing_service=None, + input_type=_DMVIEWREQ, + output_type=_DMVIEWREPLY, + serialized_options=None, + create_key=_descriptor._internal_create_key, + ), + _descriptor.MethodDescriptor( + name='DmPlayerConfig', + full_name='bilibili.community.service.dm.v1.DM.DmPlayerConfig', + index=2, + containing_service=None, + input_type=_DMPLAYERCONFIGREQ, + output_type=_RESPONSE, + serialized_options=None, + create_key=_descriptor._internal_create_key, + ), + _descriptor.MethodDescriptor( + name='DmSegOtt', + full_name='bilibili.community.service.dm.v1.DM.DmSegOtt', + index=3, + containing_service=None, + input_type=_DMSEGOTTREQ, + output_type=_DMSEGOTTREPLY, + serialized_options=None, + create_key=_descriptor._internal_create_key, + ), + _descriptor.MethodDescriptor( + name='DmSegSDK', + full_name='bilibili.community.service.dm.v1.DM.DmSegSDK', + index=4, + containing_service=None, + input_type=_DMSEGSDKREQ, + output_type=_DMSEGSDKREPLY, + serialized_options=None, + create_key=_descriptor._internal_create_key, + ), + _descriptor.MethodDescriptor( + name='DmExpoReport', + full_name='bilibili.community.service.dm.v1.DM.DmExpoReport', + index=5, + containing_service=None, + input_type=_DMEXPOREPORTREQ, + output_type=_DMEXPOREPORTRES, + serialized_options=None, + create_key=_descriptor._internal_create_key, + ), +]) +_sym_db.RegisterServiceDescriptor(_DM) + +DESCRIPTOR.services_by_name['DM'] = _DM + +# @@protoc_insertion_point(module_scope) diff --git "a/python/\347\210\254\345\217\226\345\274\271\345\271\225/crc32.py" "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/crc32.py" new file mode 100644 index 0000000..accbb45 --- /dev/null +++ "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/crc32.py" @@ -0,0 +1,73 @@ +import sys +import time + +CRCPOLYNOMIAL = 0xEDB88320 +crctable = [0 for x in range(256)] + +for i in range(256): + crcreg = i + for _ in range(8): + if (crcreg & 1) != 0: + crcreg = CRCPOLYNOMIAL ^ (crcreg >> 1) + else: + crcreg = crcreg >> 1 + crctable[i] = crcreg + +def crc32(text): + crcstart = 0xFFFFFFFF + for i in range(len(str(text))): + index = (crcstart ^ ord(str(text)[i])) & 255 + crcstart = (crcstart >> 8) ^ crctable[index] + return crcstart + +def crc32_last_index(text): + crcstart = 0xFFFFFFFF + for i in range(len(str(text))): + index = (crcstart ^ ord(str(text)[i])) & 255 + crcstart = (crcstart >> 8) ^ crctable[index] + return index + +def get_crc_index(t): + for i in range(256): + if crctable[i] >> 24 == t: + return i + return -1 + +def deep_check(i, index): + text = "" + tc=0x00 + hashcode = crc32(i) + tc = hashcode & 0xff ^ index[2] + if not (tc <= 57 and tc >= 48): + return [0] + text += str(tc - 48) + hashcode = crctable[index[2]] ^ (hashcode >>8) + tc = hashcode & 0xff ^ index[1] + if not (tc <= 57 and tc >= 48): + return [0] + text += str(tc - 48) + hashcode = crctable[index[1]] ^ (hashcode >> 8) + tc = hashcode & 0xff ^ index[0] + if not (tc <= 57 and tc >= 48): + return [0] + text += str(tc - 48) + hashcode = crctable[index[0]] ^ (hashcode >> 8) + return [1, text] + +def crack(text): + index = [0 for x in range(4)] + i = 0 + ht = int(f"0x{text}", 16) ^ 0xffffffff + for i in range(3,-1,-1): + index[3-i] = get_crc_index(ht >> (i*8)) + snum = crctable[index[3-i]] + ht ^= snum >> ((3-i)*8) + for i in range(100000000): + lastindex = crc32_last_index(i) + if lastindex == index[3]: + deepCheckData = deep_check(i, index) + if deepCheckData[0]: + break + if i == 100000000: + return -1 + return f"{i}{deepCheckData[1]}" \ No newline at end of file diff --git "a/python/\347\210\254\345\217\226\345\274\271\345\271\225/getDanMu.py" "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/getDanMu.py" new file mode 100644 index 0000000..b2352e1 --- /dev/null +++ "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/getDanMu.py" @@ -0,0 +1,25 @@ +import requests +import google.protobuf.text_format as text_format +import bili_pb2 as Danmaku + + +url = 'http://api.bilibili.com/x/v2/dm/web/seg.so' +params = { + 'type':1, # 弹幕类型 + 'oid':493424989, # cid + 'pid':210946256, # avid + 'segment_index':1 # 弹幕分段 +} +resp = requests.get(url,params) +data = resp.content + +danmaku_seg = Danmaku.DmSegMobileReply() +danmaku_seg.ParseFromString(data) + +print_log = open("danMu.txt",'w') + +for j in danmaku_seg.elems: + parse_data = text_format.MessageToString(j, as_utf8=True) + print(parse_data, file = print_log) + +print_log.close() diff --git "a/python/\347\210\254\345\217\226\345\274\271\345\271\225/midHash2userId.py" "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/midHash2userId.py" new file mode 100644 index 0000000..39e47dc --- /dev/null +++ "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/midHash2userId.py" @@ -0,0 +1,3 @@ +from crc32 import crack +midHash = '90e3491f' +print('https://space.bilibili.com/' + crack(midHash)) \ No newline at end of file diff --git "a/python/\347\210\254\345\217\226\345\274\271\345\271\225/readme.md" "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/readme.md" new file mode 100644 index 0000000..c140fbf --- /dev/null +++ "b/python/\347\210\254\345\217\226\345\274\271\345\271\225/readme.md" @@ -0,0 +1,23 @@ +已发布到 [gist](https://gist.github.com/Linhieng/e94283ab1fd0fba96b96bf02b61e42c6) + +## 🍕 安装依赖 + +```bash +pip install protobuf==3.20.0 +pip install requests +``` + +## 🍕 相关文件说明 + +- [`bili_pb2.py`](https://gist.github.com/Linhieng/e94283ab1fd0fba96b96bf02b61e42c6#file-bili_pb2-py): 将 [B站弹幕的 proto](https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/bb437d2012e6291b38c78d42755db9d836d4975f/grpc_api/bilibili/community/service/dm/v1/dm.proto) 拷贝到 [这个在线 proto 编程中](https://protogen.marcgravell.com/#), 然后输出为 python 文件 +- [`getDanMu.py`](https://gist.github.com/Linhieng/e94283ab1fd0fba96b96bf02b61e42c6#file-getdanmu-py): 用于将弹幕输出为 `danMu.txt` 文件(需要修改文件内的 `params`) +- [`cc32.py`](https://gist.github.com/Linhieng/e94283ab1fd0fba96b96bf02b61e42c6#file-crc32-py): 来自 [这篇博客](https://zhuanlan.zhihu.com/p/499708255#:~:text=%E4%B8%8B%E8%BD%BD%E5%B9%B6%E8%A7%A3%E6%9E%90%E5%BC%B9%E5%B9%95%E7%9A%84%E4%BB%A3%E7%90%86%E4%BB%A3%E7%A0%81%E5%A6%82%E4%B8%8B), [原版](https://github.com/esterTion/BiliBili_crc2mid/blob/master/crc32.htm) 是 js 实现的。 +- [`midhash2userid-py`](https://gist.github.com/Linhieng/e94283ab1fd0fba96b96bf02b61e42c6#file-midhash2userid-py): 顾名思义 + +## 🍕 参考链接 + +- https://github.com/SocialSisterYi/bilibili-API-collect/blob/master/danmaku/danmaku_proto.md +- https://github.com/esterTion/BiliBili_crc2mid/blob/master/crc32.htm +- https://blog.csdn.net/qq_39870538/article/details/124352010 +- https://zhuanlan.zhihu.com/p/392931611 +- https://zhuanlan.zhihu.com/p/499708255