random算法
㈠ java语言中，random的是怎么实现的
看过源代码，是以System.currentMillionSeconds()为种子，然后计算出来的随机数。
看API解释
public class Randomextends Objectimplements Serializable此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式对其进行修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。
如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证属性的实现，为类 Random 指定了特定的算法。为了 Java 代码的完全可移植性，Java 实现必须让类 Random 使用此处所示的所有算法。但是允许 Random 类的子类使用其他算法，只要其符合所有方法的常规协定即可。
Random 类所实现的算法使用一个 protected 实用工具方法，每次调用它都可提供最多 32 个伪随机生成的位。
㈡ 随机数算法是什么
在计算机中并没有一个真正的随机数发生器，但是可以做到使产生的数字重复率很低，这样看起来好象是真正的随机数，实现这一功能的程序叫伪随机数发生器。有关如何产生随机数的理论有许多如果要详细地讨论，需要厚厚的一本书的篇幅。不管用什么方法实现随机数发生器，都必须给它提供一个名为“种子”的初始值。而且这个值最好是随机的，或者至少这个值是伪随机的。“种子”的值通常是用快速计数寄存器或移位寄存器来生成的。下面讲一讲在c语言里所提供的随机数发生器的用法。现在的C编译器都提供了一个基于ANSI标准的伪随机数发生器函数，用来生成随机数。它们就是rand（）和srand（）函数。这二个函数的工作过程如下：”）首先给srand（）提供一个种子，它是一个unsignedint类型，其取值范围从0～65535；2）然后调用rand（），它会根据提供给srand（）的种子值返回一个随机数（在0到32767之间）3）根据需要多次调用rand（），从而不间断地得到新的随机数；4）无论什么时候，都可以给srand（）提供一个新的种子，从而进一步“随机化”rand（）的输出结果。这个过程看起来很简单，问题是如果你每次调用srand（）时都提供相同的种子值，那么，你将会得到相同的随机数序列，这时看到的现象是没有随机数，而每一次的数都是一样的了。例如，在以17为种子值调用srand（）之后，在首次调用rand（）时，得到随机数94。在第二次和第三次调用rand（）时将分别得到26602和30017，这些数看上去是很随机的（尽管这只是一个很小的数据点集合），但是，在你再次以17为种子值调用srand（）后，在对于rand（）的前三次调用中，所得的返回值仍然是在对94，26602，30017，并且此后得到的返回值仍然是在对rand（）的第一批调用中所得到的其余的返回值。因此只有再次给srand（）提供一个随机的种子值，才能再次得到一个随机数。下面的例子用一种简单而有效的方法来产生一个相当随机的“种子”值－－－－当天的时间值：g＃椋睿悖欤酰洌澹Γ欤簦唬螅簦洌椋铮瑁Γ纾簦弧。＃椋睿悖欤酰洌澹Γ欤簦唬螅簦洌欤椋猓瑁Γ纾簦弧。＃椋睿悖欤酰洌澹Γ欤簦唬螅螅Γ＃矗罚唬簦穑澹螅瑁Γ纾簦弧。＃椋睿悖欤酰洌澹Γ欤簦唬螅螅Γ＃矗罚唬簦椋恚澹猓瑁Γ纾簦弧。觯铮椋洹。恚幔椋睿ǎ觯铮椋洌。。椋睿簟。椋弧。酰睿螅椋纾睿澹洹。椋睿簟。螅澹澹洌郑幔欤弧。螅簦颍酰悖簟。簦椋恚澹狻。簦椋恚澹拢酰妫弧。妫簦椋恚澹ǎΓ幔恚穑唬簦椋恚澹拢酰妫弧。螅澹澹洌郑幔欤剑ǎǎǎǎ酰睿螅椋纾睿澹洹。椋睿簦簦椋恚澹拢酰妫簦椋恚澹Γ幔恚穑唬埃疲疲疲疲。ǎ酰睿螅椋纾睿澹洹。椋睿簦簦椋恚澹拢酰妫恚椋欤欤椋簦恚蕖。ǎ酰睿螅椋纾睿澹洹。椋睿簦簦椋恚澹拢酰妫恚椋欤欤椋簦恚弧。螅颍幔睿洌ǎǎ酰睿螅椋纾睿澹洹。椋睿簦螅澹澹洌郑幔欤弧。妫铮颍ǎ椋剑埃唬椋Γ欤簦唬保埃唬椋。穑颍椋睿簦妫ǎΓ瘢酰铮簦唬ィ叮洌Γ＃梗玻唬睿Γ瘢酰铮簦籦egjrand（））；｝上面的程序先是调用＿ftime（）来检查当前时间yc并把它的值存入结构成员timeBuf．time中wae当前时间的值从1970年1月1日开始以秒计算aeh在调用了＿ftime（）之后在结构timeBuf的成员millitm中还存入了当前那一秒已经度过的毫秒数，但在DOS中这个数字实际上是以百分之一秒来计算的。然后，把毫秒数和秒数相加，再和毫秒数进行异或运算。当然也可以对这两个结构成员进行更多的计算，以控制se．．．．．．余下全文＞＞
㈢ 随机函数random()的算法
Randomize
Text1.Text = Int((300 * Rnd()) + 200)
产生200-500的随机数。
+200代表下线。
㈣ 请高人指教java中random函数的详细知识！本人不胜感激！谢谢了！
java.util
类 Random
java.lang.Object
java.util.Random
所有已实现的接口：
Serializable
直接已知子类：
SecureRandom
--------------------------------------------------------------------------------
public class Randomextends Objectimplements Serializable此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式对其进行修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。
如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证属性的实现，为类 Random 指定了特定的算法。为了 Java 代码的完全可移植性，Java 实现必须让类 Random 使用此处所示的所有算法。但是允许 Random 类的子类使用其他算法，只要其符合所有方法的常规协定即可。
Random 类所实现的算法使用一个 protected 实用工具方法，每次调用它都可提供最多 32 个伪随机生成的位。
很多应用程序会发现 Math 类中的 random 方法更易于使用。
从以下版本开始：
JDK1.0
另请参见：
Math.random(), 序列化表格
--------------------------------------------------------------------------------
构造方法摘要
Random()
创建一个新的随机数生成器。
Random(long seed)
使用单个 long 种子创建一个新随机数生成器： public Random(long seed) { setSeed(seed); } next 方法使用它来保存随机数生成器的状态。
方法摘要
protected int next(int bits)
生成下一个伪随机数。
boolean nextBoolean()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 boolean 值。
void nextBytes(byte[] bytes)
生成随机字节并将其置于用户提供的字节数组中。
double nextDouble()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0之间均匀分布的 double 值。
float nextFloat()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。
double nextGaussian()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。
int nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n)
返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。
long nextLong()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 long 值。
void setSeed(long seed)
使用单个 long 种子设置此随机数生成器的种子。
从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
构造方法详细信息
Random
public Random()创建一个新的随机数生成器。此构造方法为随机数生成器的种子设置某个值，该值与此构造方法的所有其他调用所用的值完全不同。
--------------------------------------------------------------------------------
Random
public Random(long seed)使用单个 long 种子创建一个新随机数生成器：
public Random(long seed) { setSeed(seed); }next 方法使用它来保存随机数生成器的状态。
参数：
seed - 初始种子。
另请参见：
setSeed(long)
方法详细信息
setSeed
public void setSeed(long seed)使用单个 long 种子设置此随机数生成器的种子。setSeed 的常规协定是它更改此随机数生成器对象的状态，使其状态好像是刚刚使用参数 seed 作为种子创建它的状态一样。Random 类按如下方式实现 setSeed 方法：
synchronized public void setSeed(long seed) {
this.seed = (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1);
haveNextNextGaussian = false;
}由 Random 类实现的 setSeed 恰好只使用 48 位的给定种子。但是，通常重写方法可能使用 long 参数的所有 64 位作为种子值。 注：尽管种子值是一个基本的 AtomicLong，但仍必须对此方法同步，确保 haveNextNextGaussian 的语义正确。
参数：
seed - 初始种子。
--------------------------------------------------------------------------------
next
protected int next(int bits)生成下一个伪随机数。当此数被所有其他方法使用时，子类应该重写此数。
next 的常规协定是它返回一个 int 值，并且如果参数位处于 1 和 32（包括）之间，那么返回值的多数低位都将（大致）是单独选择的位值，每个位值是 0 或 1 的机会（大致）相等。Random 类按如下方式实现 next 方法：
synchronized protected int next(int bits) {
seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);
return (int)(seed >>> (48 - bits));
}这是一个线性同余伪随机数生成器，由 D. H. Lehmer 定义，Donald E. Knuth 在《The Art of Computer Programming, Volume 2: Seminumerical Algorithms》的第 3.2.1 节中进行了描述。
参数：
bits - 随机位。
返回：
随机数生成器序列的下一个伪随机值。
从以下版本开始：
JDK1.1
--------------------------------------------------------------------------------
nextBytes
public void nextBytes(byte[] bytes)生成随机字节并将其置于用户提供的字节数组中。所生成的随机字节数等于该字节数组的长度。
参数：
bytes - 放入随机字节的非 null 字节数组。
从以下版本开始：
JDK1.1
--------------------------------------------------------------------------------
nextInt
public int nextInt()返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。nextInt 的常规协定是伪随机地生成并返回一个 int 值。所有 232 个可能 int 值的生成概率（大致）相同。Random 类按如下方式实现 nextInt 方法：
public int nextInt() { return next(32); }
返回：
下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
--------------------------------------------------------------------------------
nextInt
public int nextInt(int n)返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。nextInt 的常规协定是伪随机地生成并返回指定范围中的一个 int 值。所有 n 个可能 int 值的生成概率（大致）相同。Random 类按如下方式实现 nextInt(int n) 方法：
public int nextInt(int n) {
if (n<=0)
throw new IllegalArgumentException("n must be positive");
if ((n & -n) == n) // i.e., n is a power of 2
return (int)((n * (long)next(31)) >> 31);
int bits, val;
do {
bits = next(31);
val = bits % n;
} while(bits - val + (n-1) < 0);
return val;
}
前面的描述中使用了不明确的词“大致”，只是因为 next 方法大致为一个单独选择位的公正来源。如果它是一个随机选择位的最佳来源，那么给出的算法应该从起始范围开始完全一致地选择 int 值。
但此算法稍微有些复杂。它拒绝那些会导致不均匀分布的值（由于 2^31 无法被 n 整除）。某个值被拒绝的概率取决于 n。最坏的情况是 n=2^30+1，拒绝的概率是 1/2，循环终止前的预计迭代次数是 2。
此算法特别对待 n 是 2 次幂的情况：它从基础的伪随机数生成器中返回正确的高位数。在不是特殊处理的情况中，将返回正确的低 位数。众所周知，线性同余伪随机数生成器（比如此类所实现的）在其低位的值序列中有 short periods。因此，如果 n 是 2 次幂（幂值较小），则这种特殊情况会导致对此方法的后续调用会返回其长度大大增加的值序列。
参数：
n - 所返回随机数的范围。必须为正数。
返回：
一个伪随机数，处于 0（包括）和 n（包括）之间均匀分布的 int 值。
抛出：
IllegalArgumentException - n 不是正数。
从以下版本开始：
1.2
--------------------------------------------------------------------------------
nextLong
public long nextLong()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 long 值。nextLong 的常规协定是伪随机地生成并返回一个 long 值。所有 264 个可能 long 值的生成概率（大致）相同。Random 类按如下方式实现 nextLong 方法： public long nextLong() { return ((long)next(32) << 32) + next(32); }
返回：
下一个伪随机数，它是此随机数生成器的序列中均匀分布的 long 值。
--------------------------------------------------------------------------------
nextBoolean
public boolean nextBoolean()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 boolean 值。nextBoolean 的常规协定是伪随机地生成并返回一个 boolean 值。值 true 和 false 的生成概率（大致）相同。Random 类按如下方式实现 nextBoolean 方法：
public boolean nextBoolean() {return next(1) != 0;}
返回：
下一个伪随机数，它是此随机数生成器的序列中均匀分布的 boolean 值。
从以下版本开始：
1.2
--------------------------------------------------------------------------------
nextFloat
public float nextFloat()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。
nextFloat 的常规协定是伪随机地生成并返回一个从 0.0f（包括）到 1.0f（包括）范围内均匀选择（大致）的 float 值。所有 224 个可能 float 值（其形式为 m x 2-24，其中 m 是一个小于 224 的正整数）的生成概率（大致）相同。Random 类按如下方式实现 nextFloat 方法：
public float nextFloat() {
return next(24) / ((float)(1 << 24));
}前面的描述中使用了不明确的词“大致”，只是因为 next 方法大致为一个单独选择位的公正来源。如果它是一个随机选择位的最佳来源，那么给出的算法应该从起始范围开始完全一致地选择 float 值。
[在 Java 的早期版本中，计算的结果是错误的，因为：
return next(30) / ((float)(1 << 30));这可能看似等效（如果不是更好的话），但实际上由于浮点数舍入中的偏差，它会导致轻微的不均匀性：有效数的低位更可能是 0 而不是 1。]
返回：
下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。
--------------------------------------------------------------------------------
nextDouble
public double nextDouble()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0之间均匀分布的 double 值。
nextDouble 的常规协定是伪随机地生成并返回一个从 0.0d（包括）到 1.0d（包括）范围内均匀选择（大致）的 double 值。所有 253 个可能 float 值（其形式为 m x 2-53，其中 m 是一个小于 253 的正整数）的生成概率（大致）相同。Random 类按如下方式实现 nextDouble 方法：
public double nextDouble() {
return (((long)next(26) << 27) + next(27))
/ (double)(1L << 53);
}前面的描述中使用了不明确的词“大致”，只是因为 next 方法大致为一个单独选择位的公正来源。如果它是一个随机选择位的最佳来源，那么给出的算法应该从起始范围开始完全一致地选择 double 值。
[在 Java 的早期版本中，计算的结果是错误的，因为：
return (((long)next(27) << 27) + next(27))
/ (double)(1L << 54);这可能看似等效（如果不是更好的话），但实际上由于浮点数舍入中的偏差，它会引入较大的不均匀性：有效数的低位可能出现的 0 是 1 的三倍！这种不均匀性在实践中可能没什么关系，但是我们应该争取完美。]
返回：
下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 double 值。
--------------------------------------------------------------------------------
nextGaussian
public double nextGaussian()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。
nextGaussian 的常规协定是伪随机地生成并返回一个 double 值，该值从（大致）从具有平均值 0.0 和标准偏差 1.0 的常规标准分布中选择。Random 类按如下方式实现 nextGaussian 方法：
synchronized public double nextGaussian() {
if (haveNextNextGaussian) {
haveNextNextGaussian = false;
return nextNextGaussian;
} else {
double v1, v2, s;
do {
v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0
v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0
s = v1 * v1 + v2 * v2;
} while (s >= 1 || s == 0);
double multiplier = Math.sqrt(-2 * Math.log(s)/s);
nextNextGaussian = v2 * multiplier;
haveNextNextGaussian = true;
return v1 * multiplier;
}
}这使用了 G. E. P. Box、M. E. Muller 和 G. Marsaglia 的 polar method，该方法在 Donald E. Knuth 的《The Art of Computer Programming, Volume 2:Seminumerical Algorithms》的第 3.4.1 节，小节 C，算法 P 中进行了描述。注意，对于一次调用 Math.log 和一次调用 Math.sqrt 而言，它生成了两个单独的值。
返回：
下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。
这是我从API里直接拷过来的，你可以在网上下载java api，网上有很多资源，有中文版的
㈤ 随机数算法是什么
在计算机中并没有一个真正的随机数发生器，但是可以做到使产生的数字重复率很低，这样看起来好象是真正的随机数，实现这一功能的程序叫伪随机数发生器。有关如何产生随机数的理论有许多如果要详细地讨论，需要厚厚的一本书的篇幅。不管用什么方法实现随机数发生器，都必须给它提供一个名为“种子”的初始值。而且这个值最好是随机的，或者至少这个值是伪随机的。“种子”的值通常是用快速计数寄存器或移位寄存器来生成的。下面讲一讲在C语言里所提供的随机数发生器的用法。现在的C编译器都提供了一个基于ANSI标准的伪随机数发生器函数，用来生成随机数。它们就是rand（）和srand（）函数。这二个函数的工作过程如下：”）首先给srand（）提供一个种子，它是一个unsignedint类型，其取值范围从0～65535；2）然后调用rand（），它会根据提供给srand（）的种子值返回一个随机数（在0到32767之间）3）根据需要多次调用rand（），从而不间断地得到新的随机数；4）无论什么时候，都可以给srand（）提供一个新的种子，从而进一步“随机化”rand（）的输出结果。这个过程看起来很简单，问题是如果你每次调用srand（）时都提供相同的种子值，那么，你将会得到相同的随机数序列，这时看到的现象是没有随机数，而每一次的数都是一样的了。例如，在以17为种子值调用srand（）之后，在首次调用rand（）时，得到随机数94。在第二次和第三次调用rand（）时将分别得到26602和30017，这些数看上去是很随机的（尽管这只是一个很小的数据点集合），但是，在你再次以17为种子值调用srand（）后，在对于rand（）的前三次调用中，所得的返回值仍然是在对94，26602，30017，并且此后得到的返回值仍然是在对rand（）的第一批调用中所得到的其余的返回值。因此只有再次给srand（）提供一个随机的种子值，才能再次得到一个随机数。下面的例子用一种简单而有效的方法来产生一个相当随机的“种子”值－－－－当天的时间值：g＃椋睿悖欤酰洌澹Γ欤簦唬螅簦洌椋铮瑁Γ纾簦弧。＃椋睿悖欤酰洌澹Γ欤簦唬螅簦洌欤椋猓瑁Γ纾簦弧。＃椋睿悖欤酰洌澹Γ欤簦唬螅螅Γ＃矗罚唬簦穑澹螅瑁Γ纾簦弧。＃椋睿悖欤酰洌澹Γ欤簦唬螅螅Γ＃矗罚唬簦椋恚澹猓瑁Γ纾簦弧。觯铮椋洹。恚幔椋睿ǎ觯铮椋洌。。椋睿簟。椋弧。酰睿螅椋纾睿澹洹。椋睿簟。螅澹澹洌郑幔欤弧。螅簦颍酰悖簟。簦椋恚澹狻。簦椋恚澹拢酰妫弧。妫簦椋恚澹ǎΓ幔恚穑唬簦椋恚澹拢酰妫弧。螅澹澹洌郑幔欤剑ǎǎǎǎ酰睿螅椋纾睿澹洹。椋睿簦簦椋恚澹拢酰妫簦椋恚澹Γ幔恚穑唬埃疲疲疲疲。ǎ酰睿螅椋纾睿澹洹。椋睿簦簦椋恚澹拢酰妫恚椋欤欤椋簦恚蕖。ǎ酰睿螅椋纾睿澹洹。椋睿簦簦椋恚澹拢酰妫恚椋欤欤椋簦恚弧。螅颍幔睿洌ǎǎ酰睿螅椋纾睿澹洹。椋睿簦螅澹澹洌郑幔欤弧。妫铮颍ǎ椋剑埃唬椋Γ欤簦唬保埃唬椋。穑颍椋睿簦妫ǎΓ瘢酰铮簦唬ィ叮洌Γ＃梗玻唬睿Γ瘢酰铮簦籦egjrand（））；｝上面的程序先是调用＿ftime（）来检查当前时间yc并把它的值存入结构成员timeBuf．time中wae当前时间的值从1970年1月1日开始以秒计算aeh在调用了＿ftime（）之后在结构timeBuf的成员millitm中还存入了当前那一秒已经度过的毫秒数，但在DOS中这个数字实际上是以百分之一秒来计算的。然后，把毫秒数和秒数相加，再和毫秒数进行异或运算。当然也可以对这两个结构成员进行更多的计算，以控制se．．．．．．余下全文＞＞
㈥ RandomForest随机森林算法
https://blog.csdn.net/qq_16633405/article/details/61200502
http://blog.itpub.net/12199764/viewspace-1572056/
https://blog.csdn.net/colourful_sky/article/details/82082854
随机森林中随机是核心，通过随机的选择样本、特征，降低了决策树之间的相关性。随机森林中的随机主要有两层意思，一是随机在原始训练数据中有放回的选取等量的数据作为训练样本，二是在建立决策树时，随机的选特征中选取一部分特征建立决策树。这两种随机使得各个决策树之间的相关性小，进一步提高模型的准确性。
随机森林未用到决策树的剪枝，那怎样控制模型的过拟合呢？主要通过控制 树的深度(max_depth)，结点停止分裂的最小样本数（min_size）等参数。随机森林还可以处理缺失值。
假设训练集中n个样本，每个样本有d个特征，需要训练一个包含T棵数的随机森林，具体的算法流程如下所示：
1、对于T棵决策树，分别重复如下操作：a、使用Bootstrap抽样，从训练集D获得大小为n的训练集D； b、从d个特征中随机选取m（m
2、如果是回归问题，则最后的输出是 每个树输出的均值；
3、如果是分类问题，则根据投票原则，确定最终的类别。
每棵树的生成都是随机的，至于随机选取的特征数，如何决定随机选取的特征数的大小呢，主要有两种方法，一种是交叉验证，另外一种的经验性设置 m= log_2 d +1。
1、分类间隔：分类间隔是指森林中正确分类样本的决策树的比例减去错误分类的决策树的比例，通过平均每个样本的分类间隔得到随机森林的分类间隔。对于分类间隔，当然是越大越好，大的分类间隔说明模型的分类效果比较稳定，泛化效果好。
2、袋外误差：对于每棵树都有一部分样本而没有被抽取到，这样的样本就被称为袋外样本，随机森林对袋外样本的预测错误率被称为袋外误差（Out-Of-Bag Error,OOB）。计算方式如下所示：
（1）对于每个样本，计算把该样本作为袋外样本的分类情况；
（2）以投票的方式确定该样本的分类结果；
（3）将误分类样本个数占总数的比率作为随机森林的袋外误差。
3、变量重要程度刻画：其实变量重要程度刻画不能算是模型性能评估里面，因为有的实际应用中需要查看这么多的特征中到底那一部分特征是相对重要的特征，这个时候变量的重要程度的刻画就显得尤为重要了。其计算方式主要有一下两种方式：
（1）通过计算特征的平均信息增益大小得出；
（2）通过计算每个特征对模型准确率的影响，通过打乱样本中某一特征的特征值顺序，产生新样本，将新样本放入建立好的随机森林模型计算准确率。相对于不重要的特征，即使打乱了顺序也不会对结果产生很大的影响，对于重要的特征，会对结果产生很大的影响的。
优点 ：
1、对于大部分的数据，它的分类效果比较好。
2、能处理高维特征，不容易产生过拟合，模型训练速度比较快，特别是对于大数据而言。
3、在决定类别时，它可以评估变数的重要性。
4、对数据集的适应能力强：既能处理离散型数据，也能处理连续型数据，数据集无需规范化。
缺点 ：
1、随机森林容易产生过拟合，特别是在数据集相对小或者是低维数据集的时候。
2、 计算速度比单个的决策树慢。
3、 当我们需要推断超出范围的独立变量或非独立变量，随机森林做得并不好。
分类问题
回归问题
常用方法 ：参考 https://blog.csdn.net/w952470866/article/details/78987265
predict_proba(x)：给出带有概率值的结果。每个点在所有label（类别）的概率和为1。
predict(x)：预测X的结果。内部还是调用的predict_proba()，根据概率的结果看哪个类型的预测值最高就是哪个类型。
predict_log_proba(x)：和predict_proba基本上一样，只是把结果给做了log()处理。
fit(X, y, sample_weight=None)： 从训练数据集(X,y)上建立一个决策树森林。x为训练样本，y为目标值（分类中的类标签，回归中的实数）。
参数
和GBDT对比，GBDT的框架参数比较多，重要的有最大迭代器个数，步长和子采样比例，调参起来比较费力。但是RandomForest则比较简单，这是因为bagging框架里的各个弱学习器之间是没有依赖关系的，这减小的调参的难度。换句话说，达到同样的调参效果，RandomForest调参时间要比GBDT少一些。
Bagging框架参数 ：
n_estimators：最大的弱学习器个数（建立随机森林分类器（树）的个数）。太小容易欠拟合，太大又容易过拟合，一般选择一个适中的数值。增大可以降低整体模型的方差，提升模型的准确度，且不会对子模型的偏差和方差有任何影响。由于降低的是整体模型方差公式的第二项，故准确度的提高有一个上限。在实际应用中，可以在1至200之间取值；
n_jobs：引擎允许使用处理器的数量。 若值为1则只能使用一个处理器， 值为-1则表示没有限制。设置n_jobs可以加快模型计算速度；
oob_score：是否采用袋外误差来评估模型的好坏，默认为 False，推荐设置为True，因为袋外分数反应了一个模型拟合后的泛化能力；
CART决策树参数 ：
max_features: RF划分时考虑的最大特征数。可以使用很多种类型的值，默认是"None",意味着划分时考虑所有的特征数；如果是"log2"意味着划分时最多考虑log2N个特征；如果是"sqrt"或者"auto"意味着划分时最多考虑N−−√N个特征。如果是整数，代表考虑的特征绝对数。如果是浮点数，代表考虑特征百分比，即考虑（百分比xN）取整后的特征数，其中N为样本总特征数。一般来说，如果样本特征数不多，比如小于50，我们用默认的"None"就可以了，如果特征数非常多，我们可以灵活使用刚才描述的其他取值来控制划分时考虑的最大特征数，以控制决策树的生成时间。
max_depth: 决策树最大深度。默认为"None"，决策树在建立子树的时候不会限制子树的深度这样建树时，会使每一个叶节点只有一个类别，或是达到min_samples_split。一般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多，特征也多的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。常用的可以取值10-100之间。
min_samples_split: 内部节点再划分所需最小样本数，默认2。这个值限制了子树继续划分的条件，如果某节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分。 默认是2.如果样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值。
min_samples_leaf:叶子节点最少样本数。 这个值限制了叶子节点最少的样本数，如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝。 默认是1,可以输入最少的样本数的整数，或者最少样本数占样本总数的百分比。如果样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值。
min_weight_fraction_leaf：叶子节点最小的样本权重和。这个值限制了叶子节点所有样本权重和的最小值，如果小于这个值，则会和兄弟节点一起被剪枝。 默认是0，就是不考虑权重问题。一般来说，如果我们有较多样本有缺失值，或者分类树样本的分布类别偏差很大，就会引入样本权重，这时我们就要注意这个值了。
max_leaf_nodes: 最大叶子节点数。通过限制最大叶子节点数，可以防止过拟合，默认是"None”，即不限制最大的叶子节点数。如果加了限制，算法会建立在最大叶子节点数内最优的决策树。如果特征不多，可以不考虑这个值，但是如果特征分成多的话，可以加以限制，具体的值可以通过交叉验证得到。
min_impurity_split: 节点划分最小不纯度。这个值限制了决策树的增长，如果某节点的不纯度(基于基尼系数，均方差)小于这个阈值，则该节点不再生成子节点，即为叶子节点 。一般不推荐改动默认值1e-7。
上面的决策树参数中最重要的包括最大特征数 max_features ， 最大深度 max_depth ， 内部节点再划分所需最小样本数 min_samples_split 和叶子节点最少样本数 min_samples_leaf 。
参数调优 ：随机森林参数的调优在数据分析和挖掘中也占有一定的地位，学会好的调优方法能够达到事半功倍的效果。调优参考 https://blog.csdn.net/cherdw/article/details/54971771
㈦ c语言里 random函数怎么实现的
rand函数是根据一个数（我们可以称它为种子）为基准，以某个递推公式推算出来的一系数，当这系列数很大的时候，就符合正态公布，从而相当于产生了随机数，
但这产生的并不是真意正义上的随机数，是一个伪随机数，当计算机正常开机后，这个种子的值是定了的，除非你破坏了系统，为了改变这个种子的值。
种子相同，产生的随机序列相同。这样做的好处是，方便我们产生一组固定的随机序列，用来调试程序。
C提供了srand()函数，用来设置种子，它的原形是void srand( int a)。
在调用rand函数产生随机数前，应该先利用srand()设好随机数种子，如果未设随机数种子，默认种子为1。
㈧ random函数的用法
用法：
1、随机生成（0,1）之间的浮点数
random.random()
2、随机生成100-200的整数
random.randint(100,200)
3、随机产生范围为10间隔为2的数
random.randrange(0,11,2)
注：这里输出（0,2,4,6,8,10）中一个
4、从序列中随机抽选一个数
random.choice(list)
5、随机排序
random.shuffle(list)
注：list元素为数值型
从序列中获取指定长度为3的字符
(8)random算法扩展阅读：
Python的random方法
random.random()用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。
print random.uniform(10, 20)print random.uniform(20, 10)
#18.7356606526
#12.5798298022
random.randint（）用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，Python生成随机数
print random.randint(12, 20) #生成的随机数n: 12 <= n <= 20print random.randint(20, 20) #结果永远是20
print random.randint(20, 10) #该语句是错误的。
下限必须小于上限。
㈨ random 和 rand 算法一样吗
不一样，看下面具体比较！
Random（int n）函数与rand（）函数的比较
1、 Random（int n）：randomize，random 不是ANSI C标准，random函数不能在GCC,VC等编译器下编译通过
2、 Rand()函数则可以通过GCC,VC等编译器
3、 无论 Random（int n）函数或rand（）函数要想随机产生数，都要设置一个种子，否则产生的随机数均是相同的。
4、 设置种子可以用：srand(int)函数来，同时要结合时间函数，使得每次种子不相同，即可产生不同的随机数，因此要引入头文件：#include<time.h>
下面举个例子：在编写俄罗斯方块代码中，要选择不同的图形，实现的代码如下： #include<stdio.h> #include<stdlib.h> #include<time.h> main()
{ int aa1[4][4]={{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0}}; int aa2[4][4]={{0,0,0,0},{0,0,1,1},{0,1,1,0},{0,0,0,0}}; int aa3[4][4]={{0,0,0,0},{0,1,1,0},{1,1,0,0},{0,0,0,0}}; int aa4[4][4]={{0,1,0,0},{0,1,0,0},{0,1,0,0},{1,1,0,0}}; int aa5[4][4]={{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,1,0}}; int aa6[4][4]={{0,0,0,0},{0,1,1,0},{0,1,1,0},{0,0,0,0}}; int aa[6]={0,1,2,3,4,5}; int a,i,j;
srand((unsigned)time(0)); a=rand()%5;
㈩ java关于Random的用法
在Java的API帮助文档中，Random函数功能的描述：
1、java.util.Random类中实现的随机算法是伪随机，也就是有规则的随机，所谓有规则的就是在给定种(seed)的区间内随机生成数字；
2、相同种子数的Random对象，相同次数生成的随机数字是完全相同的；
3、Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率均等。
(10)random算法扩展阅读：
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等
语言特点：
1.简单性：
Java看起来设计得很像C++，但是为了使语言小和容易熟悉，设计者们把C++语言中许多可用的特征去掉了，这些特征是一般程序员很少使用的。例如，Java不支持go to语句，代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载（overload）和多继承特征，并且不使用主文件，免去了预处理程序。
因为Java没有结构，数组和串都是对象，所以不需要指针。Java能够自动处理对象的引用和间接引用，实现自动的无用单元收集，使用户不必为存储管理问题烦恼，能更多的时间和精力花在研发上。
2.面向对象：
Java是一个面向对象的语言。对程序员来说，这意味着要注意应中的数据和操纵数据的方法（method），而不是严格地用过程来思考。在一个面向对象的系统中，类（class）是数据和操作数据的方法的集合。数据和方法一起描述对象（object）的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的，使得子类可以从超类继承行为。
在这个类层次体系中有一个根类，它是具有一般行为的类。Java程序是用类来组织的。Java还包括一个类的扩展集合，分别组成各种程序包（Package），用户可以在自己的程序中使用。例如，Java提供产生图形用户接口部件的类（java.awt包），这里awt是抽象窗口工具集（abstract windowing toolkit）的缩写，处理输入输出的类（java.io包）和支持网络功能的类（java.net包）。
3.分布性：
Java设计成支持在网络上应用，它是分布式语言。Java既支持各种层次的网络连接，又以Socket类支持可靠的流（stream）网络连接，所以用户可以产生分布式的客户机和服务器。网络变成软件应用的分布运载工具。Java程序只要编写一次，就可到处运行。
4.编译和解释性：
Java编译程序生成字节码（byte-code），而不是通常的机器码。Java字节码提供对体系结构中性的目标文件格式，代码设计成可有效地传送程序到多个平台。Java程序可以在任何实现了Java解释程序和运行系统（run-time system）的系统上运行。
在一个解释性的环境中，程序开发的标准“链接”阶段大大消失了。如果说Java还有一个链接阶段，它只是把新类装进环境的过程，它是增量式的、轻量级的过程。因此，Java支持快速原型和容易试验，它将导致快速程序开发。这是一个与传统的、耗时的“编译、链接和测试”形成鲜明对比的精巧的开发过程。