离散对数用python

① python代码问题。

1. 如果在是Python解释器里运行的话，没有问题。“X,L”就是打印出X,L的值。问题应该在最后一行的X,L，如果在写成一个脚本由Python执行的话，就不能这么写了。要用"print X,L"明确告诉Python输出X,L的值。

2. Python(英语发音:/ˈpaɪθən/), 是一种面向对象、解释型计算机程序设计语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年，Python 源代码同样遵循 GPL(GNU General Public License)协议。Python语法简洁而清晰，具有丰富和强大的类库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块(尤其是C/C++)很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型(有时甚至是程序的最终界面)，然后对其中有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C/C++重写，而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。

3. 折叠在Python中学习机器学习的四个步骤：

1、首先你要使用书籍、课程、视频来学习 Python 的基础知识[2]

2、然后你必需掌握不同的模块，比如 Pandas、Numpy、Matplotlib、NLP (自然语言处理)，来处理、清理、绘图和理解数据。

3、接着你必需能够从网页抓取数据，无论是通过网站API，还是网页抓取模块Beautiful Soap。通过网页抓取可以收集数据，应用于机器学习算法。

4、最后一步，你必需学习机器学习工具，比如 Scikit-Learn，或者在抓取的数据中执行机器学习算法(ML-algorithm)。

② 关于Python的问题

不管在什么编程语言中，if语句都是用来做判断的
如果 [表达式] 就做什么事情
if的后面一定是一个表达式，这个表达式所返回的一定是一个布尔值 也就是 要么 真 要么假
在计算机语言中，真可以用数值任意的大于0的数值来表示，假只可以用0来表示
你可以想象成，一个篮子里，不管装了1个苹果还是1千万个苹果 苹果是真实存在的，而一个瓶子里如果是0个苹果 那么就是没有苹果，苹果就是不存在的，就为空。
理解了这个问题，就比较好理解上面的语句了

先看，如果a = 1 （a复制为任意的非0数值 结果都是一样）
那么if的表达式就为a a的数值为1表示表示返回的布尔值为真 那么可以执行下面的语句 打印出ss
再看，如果a = 0
那么if的表达式中a返回的布尔值为假，那么就不会再执行print('dd') 了 也就没有任何输出了

③ 北京科技大学信息与计算科学就业如何

为信息与计算科学（信计）专业正名，这是一个数学类下的专业！数学专业！说计算机专业的只能说无知了。不过现在的信计专业，包括数学作业，不代表不会一些计算机类专业的东西，数学中存在大量的复杂计算，所以编程不能不会，例如进行最优化的迭代，几百次几千次难以避免，三角函数计算，对数计算等，都难以避免。有一个说法，把信计当做是数学和计算机的交叉学科，我感觉基本正确，数学专业的基础基本都有，数分高代解几概率论，然后离散、偏微分、泛函、近世代数等都有，还有信息论等，都是有的，而数据结构、数据库、编程等计算机类的课程也有（应用数学专业也有），个人感觉大背景下信计和数学都蛮适合的，个人非常人推荐。就学校而言，北科的数学类学科其实算挺不错的，只不过光芒被材料冶金专业的光芒覆盖，不见得数学信计就不好，老师很不多，水平也很高，师德师资都没问题，缺点是有一些非常火的东西，例如python等可能没有作为课程授予，不过课程筹建等原因目前看来可以理解。本人北科信计13级学生。

④ ai工程师 需要 哪些 技能

AI工程师需要的技能：

技能一：监督学习中需要彻底掌握三个最基础的模型，包括线性回归（Linear Regression）、对数几率回归（Logistic Regression）和决策树（Decision Trees）。

技能二：了解这些模型的数学含义，能够理解这些模型的假设和解法。写实际的代码或者伪代码来描述这些模型的算法，真正达到对这些算法的掌握。“K 均值算法”有必要认真学习，做到真正的、彻底的理解。

技能三：理解假设检验容易被 AI 工程师遗忘的内容。要熟悉假设检验的基本设定和背后的假设，清楚这些假设在什么情况下可以使用，如果假设被违背了的话，又需要做哪些工作去弥补。

技能四：具备最基本的编程能力，对数据结构和基础算法有一定的掌握。对于搭建一个人工智能系统（比如搜索系统、人脸识别系统、图像检索系统、推荐系统等）有最基本的认识。

机器学习算法能够真正应用到现实的产品中去，必须要依靠一个完整的系统链路，这里面有数据链路的设计、整体系统的架构、甚至前后端的衔接等多方面的知识。

(4)离散对数用python扩展阅读：

AI工程师会做： 设计，着手对信息的分析；擅长一些特定开发领域，例如网络，操作系统，数据库或应用程序； 帮助维护组织的计算机网络和系统；在软件系统的设计，安装，测试和维护中起到关键作用。

成为一种专门的程序员，可以与Web开发人员和软件工程师合作，来把Java或其他编程语言集成到业务应用程序，软件和网站中；研究软件应用程序领域，准备软件要求和规格说明文件；为了能做到这些。

⑤ 离散对数的离散对数的应用

离散对数公钥加密算法是目前最为热门的公钥加密算法 ，其安全性要远远高于基于大数分解的RSA算法。
首先说明一下上述三位科学家公钥密码体制的运作过程（假定A和B两个人要在一个不安全通道如因特网上形成密钥以备日后加密解密所用）。
首先，A、B两人要共同公开约定一个素数q和有限域Fq中的一个生成元g；
A选定一个随机数a∈{1，2，…，q-1}（a可以认为是A之私钥），并将g a(modq)传送给B；
B选定一个随机数b∈{1，2，…，q-1}（b可以认为是B之私钥），并将gb(modq)传送给A；
此时A可以算出(g b)a(modq)，B也可以算出(g a)b(modq)，由于(gb)a(modq) = (g a)b(modq) = g ab(modq)，因此，A和B就形成了一个公共的密钥g ab(modq)，日后便可以此钥来进行传统的加密解密计算，从而达到在不安全的通道上进行保密通讯的目的。
显然，敌方可以截获到g，q，g a(modq)，g b(modq)。因此，如果敌方有快速的求解离散对数的算法，就能从已截获的上述信息中迅速求出a或b，从而算出g ab(modq)。遗憾的是，目前世界上根本就没有快速的求解离散对数的算法，因此当所选的有限域Fq很大时，a或b就很难算出。
椭圆曲线密码算法(ECC)
椭圆曲线密码系统(ECC)就是根据除以p的余数的模算术运算来描述模p的离散对数问题。这并不是形成离散对数问题基础的唯一数学结构。1985年，Neil Koblitz和Victor Miller分别独立提出了椭圆曲线密码系统(ECC)，其安全性依靠将离散对数问题应用于椭圆曲线上的点，且存在一些有力的且能用于密码系统的独特性质。ECC即可用于数字签名方案，又可用于加密方案。
定义模素数p的椭圆曲线是形如y2=x3+ax+b(mod p)的方程的解(x,y)的集合，a与b是两个数。如果(x,y)满足前述方程，那么p=(x,y)就是椭圆曲线上的点。椭圆曲线也能定义在由2m个元素组成的有限域(finite field)上，此种表示可额外提供ECC运算的效率。可以定义椭圆曲线上的两点的"加法",假设P和Q都是曲线上的点，则P+Q总是曲线上的另一点。
椭圆曲线离散对数问题可陈述如下：固定素数p域椭圆曲线，xP表示P点"加"x次。假定Q是P的倍数,使得对x，有：Q=xP ，那么椭圆曲线离散对数问题是给定P和Q求x。
ECC的安全性依赖于椭圆曲线离散对数问题的困难性。与整数因子分解问题和模P的离散对数问题一样，目前没有有效算法解椭圆曲线离散对数问题,
ECC的优势之一是椭圆曲线连对数问题被认为比整数因子分解问题和模P的离散对数问题都难。这额外的难度意味着ECC是目前已知的最强公钥密码系统之一。

⑥ 怎么有时候ln写成了log

不是
估计是你看错了
ln是以e为底，log以10为底，但是对于换底公式来说会这样
log（2,3）=log2/（log3）=ln2/（ln3），但并非说ln与log一样.............

⑦ 用python实现红酒数据集的ID3,C4.5和CART算法

ID3算法介绍
ID3算法全称为迭代二叉树3代算法（Iterative Dichotomiser 3）
该算法要先进行特征选择，再生成决策树，其中特征选择是基于“信息增益”最大的原则进行的。
但由于决策树完全基于训练集生成的，有可能对训练集过于“依赖”，即产生过拟合现象。因此在生成决策树后，需要对决策树进行剪枝。剪枝有两种形式，分别为前剪枝（Pre-Pruning）和后剪枝（Post-Pruning），一般采用后剪枝。
信息熵、条件熵和信息增益
信息熵：来自于香农定理，表示信息集合所含信息的平均不确定性。信息熵越大，表示不确定性越大，所含的信息量也就越大。
设x 1 , x 2 , x 3 , . . . x n {x_1, x_2, x_3, ...x_n}x
1

,x
2

,x
3

,...x
n

为信息集合X的n个取值，则x i x_ix
i

的概率：
P ( X = i ) = p i , i = 1 , 2 , 3 , . . . , n P(X=i) = p_i, i=1,2,3,...,n
P(X=i)=p
i

,i=1,2,3,...,n

信息集合X的信息熵为：
H ( X ) = − ∑ i = 1 n p i log ⁡ p i H(X) =- \sum_{i=1}^{n}{p_i}\log{p_i}
H(X)=−
i=1
∑
n

p
i

logp
i

条件熵：指已知某个随机变量的情况下，信息集合的信息熵。
设信息集合X中有y 1 , y 2 , y 3 , . . . y m {y_1, y_2, y_3, ...y_m}y
1

,y
2

,y
3

,...y
m

组成的随机变量集合Y，则随机变量（X，Y）的联合概率分布为
P ( x = i , y = j ) = p i j P(x=i,y=j) = p_{ij}
P(x=i,y=j)=p
ij

条件熵：
H ( X ∣ Y ) = ∑ j = 1 m p ( y j ) H ( X ∣ y j ) H(X|Y) = \sum_{j=1}^m{p(y_j)H(X|y_j)}
H(X∣Y)=
j=1
∑
m

p(y
j

)H(X∣y
j

)
由
H ( X ∣ y j ) = − ∑ j = 1 m p ( y j ) ∑ i = 1 n p ( x i ∣ y j ) log ⁡ p ( x i ∣ y j ) H(X|y_j) = - \sum_{j=1}^m{p(y_j)}\sum_{i=1}^n{p(x_i|y_j)}\log{p(x_i|y_j)}
H(X∣y
j

)=−
j=1
∑
m

p(y
j

)
i=1
∑
n

p(x
i

∣y
j

)logp(x
i

∣y
j

)
和贝叶斯公式：
p ( x i y j ) = p ( x i ∣ y j ) p ( y j ) p(x_iy_j) = p(x_i|y_j)p(y_j)
p(x
i

y
j

)=p(x
i

∣y
j

)p(y
j

)
可以化简条件熵的计算公式为:
H ( X ∣ Y ) = ∑ j = 1 m ∑ i = 1 n p ( x i , y j ) log ⁡ p ( x i ) p ( x i , y j ) H(X|Y) = \sum_{j=1}^m \sum_{i=1}^n{p(x_i, y_j)\log\frac{p(x_i)}{p(x_i, y_j)}}
H(X∣Y)=
j=1
∑
m

i=1
∑
n

p(x
i

,y
j

)log
p(x
i

,y
j

)
p(x
i

)

信息增益：信息熵-条件熵，用于衡量在知道已知随机变量后，信息不确定性减小越大。
d ( X , Y ) = H ( X ) − H ( X ∣ Y ) d(X,Y) = H(X) - H(X|Y)
d(X,Y)=H(X)−H(X∣Y)

python代码实现
import numpy as np
import math

def calShannonEnt(dataSet):
""" 计算信息熵 """
labelCountDict = {}
for d in dataSet:
label = d[-1]
if label not in labelCountDict.keys():
labelCountDict[label] = 1
else:
labelCountDict[label] += 1
entropy = 0.0
for l, c in labelCountDict.items():
p = 1.0 * c / len(dataSet)
entropy -= p * math.log(p, 2)
return entropy

def filterSubDataSet(dataSet, colIndex, value):
"""返回colIndex特征列label等于value，并且过滤掉改特征列的数据集"""
subDataSetList = []
for r in dataSet:
if r[colIndex] == value:
newR = r[:colIndex]
newR = np.append(newR, (r[colIndex + 1:]))
subDataSetList.append(newR)
return np.array(subDataSetList)

def chooseFeature(dataSet):
""" 通过计算信息增益选择最合适的特征"""
featureNum = dataSet.shape[1] - 1
entropy = calShannonEnt(dataSet)
bestInfoGain = 0.0
bestFeatureIndex = -1
for i in range(featureNum):
uniqueValues = np.unique(dataSet[:, i])
condition_entropy = 0.0

for v in uniqueValues: #计算条件熵
subDataSet = filterSubDataSet(dataSet, i, v)
p = 1.0 * len(subDataSet) / len(dataSet)
condition_entropy += p * calShannonEnt(subDataSet)
infoGain = entropy - condition_entropy #计算信息增益

if infoGain >= bestInfoGain: #选择最大信息增益
bestInfoGain = infoGain
bestFeatureIndex = i
return bestFeatureIndex

def creatDecisionTree(dataSet, featNames):
""" 通过训练集生成决策树 """
featureName = featNames[:] # 拷贝featNames，此处不能直接用赋值操作，否则新变量会指向旧变量的地址
classList = list(dataSet[:, -1])
if len(set(classList)) == 1: # 只有一个类别
return classList[0]
if dataSet.shape[1] == 1: #当所有特征属性都利用完仍然无法判断样本属于哪一类，此时归为该数据集中数量最多的那一类
return max(set(classList), key=classList.count)

bestFeatureIndex = chooseFeature(dataSet) #选择特征
bestFeatureName = featNames[bestFeatureIndex]
del featureName[bestFeatureIndex] #移除已选特征列
decisionTree = {bestFeatureName: {}}

featureValueUnique = sorted(set(dataSet[:, bestFeatureIndex])) #已选特征列所包含的类别， 通过递归生成决策树
for v in featureValueUnique:
FeatureName = featureName[:]
subDataSet = filterSubDataSet(dataSet, bestFeatureIndex, v)
decisionTree[bestFeatureName][v] = creatDecisionTree(subDataSet, FeatureName)
return decisionTree

def classify(decisionTree, featnames, featList):
""" 使用训练所得的决策树进行分类 """
classLabel = None
root = decisionTree.keys()[0]
firstGenDict = decisionTree[root]
featIndex = featnames.index(root)
for k in firstGenDict.keys():
if featList[featIndex] == k:
if isinstance(firstGenDict[k], dict): #若子节点仍是树，则递归查找
classLabel = classify(firstGenDict[k], featnames, featList)
else:
classLabel = firstGenDict[k]
return classLabel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
下面用鸢尾花数据集对该算法进行测试。由于ID3算法只能用于标称型数据，因此用在对连续型的数值数据上时，还需要对数据进行离散化，离散化的方法稍后说明，此处为了简化，先使用每一种特征所有连续性数值的中值作为分界点，小于中值的标记为1，大于中值的标记为0。训练1000次，统计准确率均值。

from sklearn import datasets
from sklearn.model_selection import train_test_split

iris = datasets.load_iris()
data = np.c_[iris.data, iris.target]

scoreL = []
for i in range(1000): #对该过程进行10000次
trainData, testData = train_test_split(data) #区分测试集和训练集

featNames = iris.feature_names[:]
for i in range(trainData.shape[1] - 1): #对训练集每个特征，以中值为分界点进行离散化
splitPoint = np.mean(trainData[:, i])
featNames[i] = featNames[i]+'<='+'{:.3f}'.format(splitPoint)
trainData[:, i] = [1 if x <= splitPoint else 0 for x in trainData[:, i]]
testData[:, i] = [1 if x <= splitPoint else 0 for x in testData[:, i]]

decisionTree = creatDecisionTree(trainData, featNames)
classifyLable = [classify(decisionTree, featNames, td) for td in testData]
scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))
print 'score: ', np.mean(scoreL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
输出结果为：score: 0.7335，即准确率有73%。每次训练和预测的准确率分布如下：

数据离散化
然而，在上例中对特征值离散化的划分点实际上过于“野蛮”，此处介绍一种通过信息增益最大的标准来对数据进行离散化。原理很简单，当信息增益最大时，说明用该点划分能最大程度降低数据集的不确定性。
具体步骤如下：

对每个特征所包含的数值型特征值排序
对相邻两个特征值取均值，这些均值就是待选的划分点
用每一个待选点把该特征的特征值划分成两类，小于该特征点置为1， 大于该特征点置为0，计算此时的条件熵，并计算出信息增益
选择信息使信息增益最大的划分点进行特征离散化
实现代码如下：

def filterRawData(dataSet, colIndex, value, tag):
""" 用于把每个特征的连续值按照区分点分成两类，加入tag参数，可用于标记筛选的是哪一部分数据"""
filterDataList = []
for r in dataSet:
if (tag and r[colIndex] <= value) or ((not tag) and r[colIndex] > value):
newR = r[:colIndex]
newR = np.append(newR, (r[colIndex + 1:]))
filterDataList.append(newR)
return np.array(filterDataList)

def dataDiscretization(dataSet, featName):
""" 对数据每个特征的数值型特征值进行离散化 """
featureNum = dataSet.shape[1] - 1
entropy = calShannonEnt(dataSet)

for featIndex in range(featureNum): #对于每一个特征
uniqueValues = sorted(np.unique(dataSet[:, featIndex]))
meanPoint = []

for i in range(len(uniqueValues) - 1): # 求出相邻两个值的平均值
meanPoint.append(float(uniqueValues[i+1] + uniqueValues[i]) / 2.0)
bestInfoGain = 0.0
bestMeanPoint = -1
for mp in meanPoint: #对于每个划分点
subEntropy = 0.0 #计算该划分点的信息熵
for tag in range(2): #分别划分为两类
subDataSet = filterRawData(dataSet, featIndex, mp, tag)
p = 1.0 * len(subDataSet) / len(dataSet)
subEntropy += p * calShannonEnt(subDataSet)

## 计算信息增益
infoGain = entropy - subEntropy
## 选择最大信息增益
if infoGain >= bestInfoGain:
bestInfoGain = infoGain
bestMeanPoint = mp
featName[featIndex] = featName[featIndex] + "<=" + "{:.3f}".format(bestMeanPoint)
dataSet[:, featIndex] = [1 if x <= bestMeanPoint else 0 for x in dataSet[:, featIndex]]
return dataSet, featName
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
重新对数据进行离散化，并重复该步骤1000次，同时用sklearn中的DecisionTreeClassifier对相同数据进行分类，分别统计平均准确率。运行代码如下:

from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
scoreL = []
scoreL_sk = []
for i in range(1000): #对该过程进行1000次
featNames = iris.feature_names[:]
trainData, testData = train_test_split(data) #区分测试集和训练集
trainData_tmp = .(trainData)
testData_tmp = .(testData)
discritizationData, discritizationFeatName= dataDiscretization(trainData, featNames) #根据信息增益离散化
for i in range(testData.shape[1]-1): #根据测试集的区分点离散化训练集
splitPoint = float(discritizationFeatName[i].split('<=')[-1])
testData[:, i] = [1 if x<=splitPoint else 0 for x in testData[:, i]]
decisionTree = creatDecisionTree(trainData, featNames)
classifyLable = [classify(decisionTree, featNames, td) for td in testData]
scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))

clf = DecisionTreeClassifier('entropy')
clf.fit(trainData[:, :-1], trainData[:, -1])
clf.predict(testData[:, :-1])
scoreL_sk.append(clf.score(testData[:, :-1], testData[:, -1]))

print 'score: ', np.mean(scoreL)
print 'score-sk: ', np.mean(scoreL_sk)
fig = plt.figure(figsize=(10, 4))
plt.subplot(1,2,1)
pd.Series(scoreL).hist(grid=False, bins=10)
plt.subplot(1,2,2)
pd.Series(scoreL_sk).hist(grid=False, bins=10)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
两者准确率分别为：
score: 0.7037894736842105
score-sk: 0.7044736842105263

准确率分布如下：

两者的结果非常一样。
（但是。。为什么根据信息熵离散化得到的准确率比直接用均值离散化的准确率还要低啊？？哇的哭出声。。）

最后一次决策树图形如下：

决策树剪枝
由于决策树是完全依照训练集生成的，有可能会有过拟合现象，因此一般会对生成的决策树进行剪枝。常用的是通过决策树损失函数剪枝，决策树损失函数表示为:
C a ( T ) = ∑ t = 1 T N t H t ( T ) + α ∣ T ∣ C_a(T) = \sum_{t=1}^TN_tH_t(T) +\alpha|T|
C
a

(T)=
t=1
∑
T

N
t

H
t

(T)+α∣T∣

其中，H t ( T ) H_t(T)H
t

(T)表示叶子节点t的熵值，T表示决策树的深度。前项∑ t = 1 T N t H t ( T ) \sum_{t=1}^TN_tH_t(T)∑
t=1
T

N
t

H
t

(T)是决策树的经验损失函数当随着T的增加，该节点被不停的划分的时候，熵值可以达到最小，然而T的增加会使后项的值增大。决策树损失函数要做的就是在两者之间进行平衡，使得该值最小。
对于决策树损失函数的理解，如何理解决策树的损失函数? - 陶轻松的回答 - 知乎这个回答写得挺好，可以按照答主的思路理解一下

C4.5算法
ID3算法通过信息增益来进行特征选择会有一个比较明显的缺点：即在选择的过程中该算法会优先选择类别较多的属性（这些属性的不确定性小，条件熵小，因此信息增益会大），另外，ID3算法无法解决当每个特征属性中每个分类都只有一个样本的情况（此时每个属性的条件熵都为0）。
C4.5算法ID3算法的改进，它不是依据信息增益进行特征选择，而是依据信息增益率，它添加了特征分裂信息作为惩罚项。定义分裂信息：
S p l i t I n f o ( X , Y ) = − ∑ i n ∣ X i ∣ ∣ X ∣ log ⁡ ∣ X i ∣ ∣ X ∣ SplitInfo(X, Y) =-\sum_i^n\frac{|X_i|}{|X|}\log\frac{|X_i|}{|X|}
SplitInfo(X,Y)=−
i
∑
n

∣X∣
∣X
i

∣

log
∣X∣
∣X
i

∣

则信息增益率为：
G a i n R a t i o ( X , Y ) = d ( X , Y ) S p l i t I n f o ( X , Y ) GainRatio(X,Y)=\frac{d(X,Y)}{SplitInfo(X, Y)}
GainRatio(X,Y)=
SplitInfo(X,Y)
d(X,Y)

关于ID3和C4.5算法
在学习分类回归决策树算法时，看了不少的资料和博客。关于这两个算法，ID3算法是最早的分类算法，这个算法刚出生的时候其实带有很多缺陷：

无法处理连续性特征数据
特征选取会倾向于分类较多的特征
没有解决过拟合的问题
没有解决缺失值的问题
即该算法出生时是没有带有连续特征离散化、剪枝等步骤的。C4.5作为ID3的改进版本弥补列ID3算法不少的缺陷：

通过信息最大增益的标准离散化连续的特征数据
在选择特征是标准从“最大信息增益”改为“最大信息增益率”
通过加入正则项系数对决策树进行剪枝
对缺失值的处理体现在两个方面：特征选择和生成决策树。初始条件下对每个样本的权重置为1。
特征选择：在选取最优特征时，计算出每个特征的信息增益后，需要乘以一个**“非缺失值样本权重占总样本权重的比例”**作为系数来对比每个特征信息增益的大小
生成决策树：在生成决策树时，对于缺失的样本我们按照一定比例把它归属到每个特征值中，比例为该特征每一个特征值占非缺失数据的比重
关于C4.5和CART回归树
作为ID3的改进版本，C4.5克服了许多缺陷，但是它自身还是存在不少问题：

C4.5的熵运算中涉及了对数运算，在数据量大的时候效率非常低。
C4.5的剪枝过于简单
C4.5只能用于分类运算不能用于回归
当特征有多个特征值是C4.5生成多叉树会使树的深度加深
————————————————
版权声明：本文为CSDN博主“Sarah Huang”的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44794704/article/details/89406612

⑧ (p+1)(p-4)+7p+8公式法

导语

本课堂用通俗易懂的系列内容为大家呈现区块链与密码学领域相关知识。这里有知识也有故事，从感兴趣到有乐趣，点宽课堂等你来学。

这个系列中的课程内容首先从比特币着手进行入门介绍，再延伸至区块链的相关技术原理与发展趋势，然后深入浅出地依次介绍在区块链中应用的各类密码学技术。欢迎大家订阅本公众号，持续进行学习。

【本课堂内容全部选编自PlatON首席密码学家、武汉大学国家网络安全学院教授、博士生导师何德彪教授的《区块链与密码学》授课讲义、教材及互联网，版权归属其原作者所有，如有侵权请立即与我们联系，我们将及时处理。】

6.3

其他数字签名算法

EIGamal算法

数字签名一般利用公钥密码技术来实现，其中私钥用来签名，公钥用来验证签名。ElGamal公钥密码算法是在密码协议中有着重要应用的一类公钥密码算法，其安全性是基于有限域上离散对数学问题的难解性。它至今仍是一个安全性良好的公钥密码算法。它既可用于加密又可用于数字签名的公钥密码体制。

假设p是一个大素数，g是GF(p)的生成元。Alice的公钥为y = gx mod p, g，p私钥为x。

签名算法：

• Alice用H将消息m进行处理，得h=H(m).

• Alice选择秘密随机数k，满足

0

计算

r=gk (mod p)

s=(h－ x · r) · k-1(mod (p－1))

• Alice将(m，r，s)发送给Bob

验证签名过程：

接收方收到M与其签名(r，s)后：

• 计算消息M的Hash值H(M)

• 验证公式

成立则确认为有效签名，否则认为签名是伪造的

PSS算法的编码操作过程

上述方案的安全性是基于如下离散对数问题的：已知大素数p、GF(p的生成元g和非零元素y∈GF(p)，求解唯一的整数k, 0≤k≤p – 2，使得y≡gk (mod p)，k称为y对g的离散对数。

在1996年的欧洲密码学会(Proceedings of EUROCRYPT 96)上，David Pointcheval和Jacques Stern给出一个ElGamal签名的变体，并基于所谓分叉技术证明了在随机预言模型下所给方案是安全的(在自适应选择消息攻击下能抗击存在性伪造)。

Schnorr算法

Schnorr签名方案是一个短签名方案，它是ElGamal签名方案的变形，其安全性是基于离散对数困难性和哈希函数的单向性的。

假设p和q是大素数，是q能被p-1整除，q是大于等于160 bit的整数，p是大于等于512 bit的整数，保证GF(p)中求解离散对数困难；g是GF(p)中元素，且gq≡1mod p。

密钥生成：

Alice选择随机数x为私钥，其中1

Alice计算公钥y≡gx (mod p)

签名算法：

①Alice首先随机数k，这里1

②Alice计算e=h(M, gk mod p)

③Alice计算s=k-x·e(mod q)

④Alice输出签名(e, s)

验证算法：

Bob计算gkmod p=gs·ye mod p

Bob验证e = h(M, gk mod p)是否成立，如果成立则输出“Accept”，否则输出“Reject”。

Schnorr签名与ElGamal签名的不同点：

安全性比较：在ElGamal体制中，g为域GF(p)的本原元素；而在Schnorr体制中， g只是域GF(p)的阶为q的元素，而非本原元素。因此，虽然两者都是基于离散对数的困难性，然而ElGamal的离散对数阶为p-1， Schnorr的离散对数阶为q

签名长度比较：Schnorr比ElGamal签名长度短

ElGamal：(m，r，s)，其中r的长度为|p|， s的长度为|p-1|

Schnorr：(m，e，s)，其中e的长度为|q|， s的长度为|q|


DSA算法

1991年，美国政府颁布了数字签名标准(Digital Signature Standard, DSS)，也称为数字签名算法(Digital Signature Algorithm, DSA) 。

和DES一样，DSS也引起了激烈的争论，反对者认为：密钥太短、效率不如RSA高、不能实现数据加密并怀疑NIST在DSS中留有后门。

随后，美国政府对其做了一些改进，目前DSS的应用已经十分广泛，并被一些国际标准化组织采纳为国际标准。2000年，美国政府将RSA和椭圆曲线密码引入到数字签名标准中，进一步丰富了DSA算法。

DSA的主要参数：

全局公开密钥分量，可以为用户公用

p：素数，要求2L-1

q : (p-1)的素因子，2159

g : =h(p-1)/q mod p.其中h是一整数，11

用户私有密钥

x：随机或伪随机整数，要求0

用户公开密钥

y：=gx mod p

随机数k

随机或伪随机整数，要求0

DSA签名过程：

• 用户随机选取k

• 计算e=h(M)；

• 计算r=(gk mod p) mod q

• 计算s=k-1(e+x · r) mod q

• 输出(r, s)，即为消息M的数字签名
  

DSA验证过程：

• 接收者收到M, r, s后，首先验证0

• 计算e=h(M)；

• 计算w=(s)-1 mod q

• 计算u1=e · w mod q

• 计算u2=r · w mod q

• 计算①v=[(gu1 · yu2) mod p] mod q

• 如果v=r，则确认签名正确，否则拒绝

DSA算法的工作流程

今天的课程就到这里啦，下一堂课我们将学习基于椭圆曲线的数字签名算法，带大家继续了解数字签名，敬请期待！


关注点宽学园，每周持续更新区块链系列课程，小宽带你进入区块链世界。我们下节课见啦。

【区块链与密码学】课堂回顾：

FOLLOW US

© DigQuant


点击“阅读原文”，登录官网www.digquant.com，一起解锁更多金融科技姿势：涵盖 Python 、 金融基础 、 量化投资 、 区块链 、 大数据 、 人工智能 。 Dig More, Learn More！

⑨ 如何提高收集数据和分析数据的能力

大数据处理关键技术一般包括：大数据采集、大数据预处理、大数据存储及管理、大数据分析及挖掘、大数据展现和应用（大数据检索、大数据可视化、大数据应用、大数据安全等）。

如何从大数据中采集出有用的信息已经是大数据发展的关键因素之一。

想要培养数据分析的能力，可以从两部分来着手：一是数据分析方法论的建立，二是数据分析从入门到精通的知识学习。

理论：是进行分析的基础
1）基础的数据分析知识，至少知道如何做趋势分析、比较分析和细分，不然拿到一份数据就无从下手；
2）基础的统计学知识，至少基础的统计量要认识，知道这些统计量的定义和适用条件，统计学方法可以让分析过程更加严谨，结论更有说服力；
3）对数据的兴趣，以及其它的知识多多益善，让分析过程有趣起来。

实践：可以说90%的分析能力都是靠实践培养的
1）明确分析的目的。如果分析前没有明确分析的最终目标，很容易被数据绕进去，最终自己都不知道自己得出的结论到底是用来干嘛的；
2）多结合业务去看数据。数据从业务运营中来，分析当然要回归到业务中去，多熟悉了解业务可以使数据看起来更加透彻；
3）了解数据的定义和获取。最好从数据最初是怎么获取的开始了解，当然指标的统计逻辑和规则是必须熟记于心的，不然很容易就被数据给坑了；
4）最后就是不断地看数据、分析数据，这是个必经的过程，往往一个工作经验丰富的非数据分析的运营人员要比刚进来不久的数据分析师对数据的了解要深入得多，就是这个原因。

也可以采用第三方的大数据服务平台，观向数据是一款整体的数据采集、分析、可视化系统，可以帮助企业品牌发展提供科学化决策。

⑩ 请教一个python代码问题！

假设两个数带进去替换x和n就好理解了，比如power（2,3）计算2的3次方
按照代码
s=1 n>0（我们假设了n为3）
然后执行while n>0 里的n=n-1 n变成2
再执行s（这个是新的s）=s（这个是旧的s）*x 新s变为2（我们上面假设x为2）
然后返回s（下次使用时就变成了旧s）
接着判断n，依旧大于0 ，执行n=n-1 n变成1 执行s=s*x 新s变为4，然后返回s
接着判断n，依旧大于0，执行n=n-1 n变成0（意味着这次结束就将跳出循环）执行s=s*x
新s变成8
循环结束，得到结果。2的3次方是8
不知道还有什么地方不明白