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支持快速原型和容易試驗，它將導致快速程序開發。這是一個與傳統的、耗時的「編譯、鏈接和測試」形成鮮明對比的精巧的開發過程。