久久在线黄色视频,国产卡一卡二视频,欧美巨大手机在线,激情网站在线,蜜臀av免费,在线观看黄色片,中文字幕无码一区二区三区一本久道不卡,大香蕉伊人在线视频观看最新

通常，可以通過從訓(xùn)練數(shù)據(jù)集中刪除輸入特征（列）來開發(fā)更簡單，性能更好的機(jī)器學(xué)習(xí)模型。這稱為特征選擇，可以使用許多不同類型的算法。可以將特征選擇問題框架為優(yōu)化問題。在輸入要素很少的情況下，可以評估輸入要素的所有可能組合，并確定地找到最佳子集。在輸入特征數(shù)量眾多的情況下，可以使用隨機(jī)優(yōu)化算法來探索搜索空間并找到特征的有效子集。

在本教程中，您將發(fā)現(xiàn)如何在機(jī)器學(xué)習(xí)中使用優(yōu)化算法進(jìn)行特征選擇。完成本教程后，您將知道：

1、特征選擇的問題可以廣義地定義為優(yōu)化問題。

2、如何枚舉數(shù)據(jù)集輸入要素的所有可能子集。

3、如何應(yīng)用隨機(jī)優(yōu)化來選擇輸入要素的最佳子集。

教程概述

本教程分為三個部分：他們是：

1、優(yōu)化特征選擇

2、枚舉所有功能子集

3、優(yōu)化功能子集

4、優(yōu)化特征選擇

特征選擇是在開發(fā)預(yù)測模型時減少輸入變量數(shù)量的過程。

希望減少輸入變量的數(shù)量，以減少建模的計(jì)算成本，并且在某些情況下，還需要改善模型的性能。盡管可以將特征選擇算法大致分為兩種主要類型，但它們有很多不同的類型：包裝器和過濾器方法。包裝器特征選擇方法會創(chuàng)建許多具有不同輸入特征子集的模型，并根據(jù)性能指標(biāo)選擇那些導(dǎo)致最佳性能模型的特征。這些方法與變量類型無關(guān)，盡管它們在計(jì)算上可能很昂貴。RFE是包裝功能選擇方法的一個很好的例子。過濾器特征選擇方法使用統(tǒng)計(jì)技術(shù)來評估每個輸入變量和目標(biāo)變量之間的關(guān)系，這些得分將用作選擇（過濾）將在模型中使用的那些輸入變量的基礎(chǔ)。

1、包裝特征選擇：搜索性能良好的特征子集。

2、過濾特征選擇：根據(jù)特征子集與目標(biāo)的關(guān)系選擇特征子集。

流行的包裝方法是遞歸特征消除算法（RFE）。RFE的工作方式是：從訓(xùn)練數(shù)據(jù)集中的所有要素開始搜索要素的子集，然后成功刪除要素，直到保留所需數(shù)量為止。這可以通過擬合模型核心中使用的給定機(jī)器學(xué)習(xí)算法，按重要性對特征進(jìn)行排序，丟棄最不重要的特征以及重新擬合模型來實(shí)現(xiàn)。重復(fù)此過程，直到保留指定數(shù)量的功能。

包裝器特征選擇的問題可被視為優(yōu)化問題。也就是說，找到可帶來最佳模型性能的輸入要素子集。RFE是一種系統(tǒng)解決此問題的方法，盡管它可能會受到眾多功能的限制。當(dāng)特征的數(shù)量很大時，另一種方法是使用隨機(jī)優(yōu)化算法，例如隨機(jī)爬山算法。當(dāng)特征的數(shù)量相對較小時，可能會枚舉所有可能的特征子集。

1、少量輸入變量：枚舉要素的所有可能子集。

2、許多輸入要素：隨機(jī)優(yōu)化算法，用于查找要素的良好子集。

既然我們熟悉了將特征選擇作為一個優(yōu)化問題來探討的想法，那么讓我們看一下如何枚舉所有可能的特征子集。

枚舉所有功能子集

當(dāng)輸入變量的數(shù)量相對較小且模型評估相對較快時，則可能會枚舉輸入變量的所有可能子集。這意味著在給定每個可能的唯一輸入變量組的情況下，使用測試工具評估模型的性能。我們將通過一個可行的示例探索如何做到這一點(diǎn)。首先，讓我們定義一個小的二進(jìn)制分類數(shù)據(jù)集，其中包含很少的輸入功能。我們可以使用make_classification（）函數(shù)定義一個具有五個輸入變量的數(shù)據(jù)集，其中兩個是信息變量，并且有1,000行。下面的示例定義了數(shù)據(jù)集并總結(jié)了其形狀。

#?define?a?small?classification?dataset
from?sklearn.datasets?import?make_classification
#?define?dataset
X,?y?=?make_classification(n_samples=1000,?n_features=5,?n_informative=2,?n_redundant=3,?random_state=1)
#?summarize?the?shape?of?the?dataset
print(X.shape,?y.shape)

運(yùn)行示例將創(chuàng)建數(shù)據(jù)集并確認(rèn)其具有所需的形狀。

(1000,?5)?(1000,)

接下來，我們可以使用對整個數(shù)據(jù)集評估的模型來建立性能基準(zhǔn)。我們將使用DecisionTreeClassifier作為模型，因?yàn)樗男阅軐斎胱兞康倪x擇非常敏感。我們將使用良好的實(shí)踐來評估模型，例如具有三個重復(fù)和10折的重復(fù)分層k折交叉驗(yàn)證。下面列出了完整的示例。

#?evaluate?a?decision?tree?on?the?entire?small?dataset
from?numpy?import?mean
from?numpy?import?std
from?sklearn.datasets?import?make_classification
from?sklearn.model_selection?import?cross_val_score
from?sklearn.model_selection?import?RepeatedStratifiedKFold
from?sklearn.tree?import?DecisionTreeClassifier
#?define?dataset
X,?y?=?make_classification(n_samples=1000,?n_features=3,?n_informative=2,?n_redundant=1,?random_state=1)
#?define?model
model?=?DecisionTreeClassifier()
#?define?evaluation?procedure
cv?=?RepeatedStratifiedKFold(n_splits=10,?n_repeats=3,?random_state=1)
#?evaluate?model
scores?=?cross_val_score(model,?X,?y,?scoring='accuracy',?cv=cv,?n_jobs=-1)
#?report?result
print('Mean?Accuracy:?%.3f?(%.3f)'?%?(mean(scores),?std(scores)))

運(yùn)行示例將評估整個數(shù)據(jù)集上的決策樹，并報(bào)告均值和標(biāo)準(zhǔn)差分類準(zhǔn)確性。

注意：由于算法或評估程序的隨機(jī)性，或者數(shù)值精度不同，您的結(jié)果可能會有所不同。考慮運(yùn)行該示例幾次并比較平均結(jié)果。在這種情況下，我們可以看到該模型實(shí)現(xiàn)了約80.5％的精度。

Mean?Accuracy:?0.805?(0.030)

接下來，我們可以嘗試通過使用輸入功能的子集來改善模型性能。首先，我們必須選擇一種表示方式進(jìn)行枚舉。在這種情況下，我們將枚舉一組布爾值，每個輸入要素都有一個值：如果要使用該要素，則為True；如果不將該要素用作輸入，則為False。例如，對于五個輸入要素，序列[True，True，True，True，True]將使用所有輸入要素，而[True，F(xiàn)alse，F(xiàn)alse，F(xiàn)alse，F(xiàn)alse，F(xiàn)alse]僅將第一個輸入要素用作輸入。我們可以使用product（）函數(shù)枚舉length = 5的所有布爾值序列。我們必須指定有效值[True，F(xiàn)alse]和序列中的步數(shù)，該步數(shù)等于輸入變量的數(shù)量。該函數(shù)返回一個可迭代的函數(shù)，我們可以直接為每個序列枚舉。

#?determine?the?number?of?columns
n_cols?=?X.shape[1]
best_subset,?best_score?=?None,?0.0
#?enumerate?all?combinations?of?input?features
for?subset?in?product([True,?False],?repeat=n_cols):

對于給定的布爾值序列，我們可以對其進(jìn)行枚舉并將其轉(zhuǎn)換為該序列中每個True的列索引序列。

#?convert?into?column?indexes
ix?=?[i?for?i,?x?in?enumerate(subset)?if?x]

如果序列沒有列索引（對于所有False值），那么我們可以跳過該序列。

#?check?for?now?column?(all?False)
if?len(ix)?==?0:
?continue

然后，我們可以使用列索引來選擇數(shù)據(jù)集中的列。

#?select?columns
X_new?=?X[:,?ix]

然后可以像以前一樣評估數(shù)據(jù)集的此子集。

#?define?model
model?=?DecisionTreeClassifier()
#?define?evaluation?procedure
cv?=?RepeatedStratifiedKFold(n_splits=10,?n_repeats=3,?random_state=1)
#?evaluate?model
scores?=?cross_val_score(model,?X_new,?y,?scoring='accuracy',?cv=cv,?n_jobs=-1)
#?summarize?scores
result?=?mean(scores)

如果模型的準(zhǔn)確性優(yōu)于到目前為止找到的最佳序列，則可以存儲它。

#?check?if?it?is?better?than?the?best?so?far
if?best_score?is?None?or?result?>=?best_score:
?#?better?result
?best_subset,?best_score?=?ix,?result

就是這樣。結(jié)合在一起，下面列出了通過枚舉所有可能的特征子集進(jìn)行特征選擇的完整示例。

#?feature?selection?by?enumerating?all?possible?subsets?of?features
from?itertools?import?product
from?numpy?import?mean
from?sklearn.datasets?import?make_classification
from?sklearn.model_selection?import?cross_val_score
from?sklearn.model_selection?import?RepeatedStratifiedKFold
from?sklearn.tree?import?DecisionTreeClassifier
#?define?dataset
X,?y?=?make_classification(n_samples=1000,?n_features=5,?n_informative=2,?n_redundant=3,?random_state=1)
#?determine?the?number?of?columns
n_cols?=?X.shape[1]
best_subset,?best_score?=?None,?0.0
#?enumerate?all?combinations?of?input?features
for?subset?in?product([True,?False],?repeat=n_cols):
?#?convert?into?column?indexes
?ix?=?[i?for?i,?x?in?enumerate(subset)?if?x]
?#?check?for?now?column?(all?False)
?if?len(ix)?==?0:
??continue
?#?select?columns
?X_new?=?X[:,?ix]
?#?define?model
?model?=?DecisionTreeClassifier()
?#?define?evaluation?procedure
?cv?=?RepeatedStratifiedKFold(n_splits=10,?n_repeats=3,?random_state=1)
?#?evaluate?model
?scores?=?cross_val_score(model,?X_new,?y,?scoring='accuracy',?cv=cv,?n_jobs=-1)
?#?summarize?scores
?result?=?mean(scores)
?#?report?progress
?print('>f(%s)?=?%f?'?%?(ix,?result))
?#?check?if?it?is?better?than?the?best?so?far
?if?best_score?is?None?or?result?>=?best_score:
??#?better?result
??best_subset,?best_score?=?ix,?result
#?report?best
print('Done!')
print('f(%s)?=?%f'?%?(best_subset,?best_score))

運(yùn)行示例將報(bào)告所考慮特征的每個子集的模型的平均分類精度。然后在運(yùn)行結(jié)束時報(bào)告最佳子集。

注意：由于算法或評估程序的隨機(jī)性，或者數(shù)值精度不同，您的結(jié)果可能會有所不同。考慮運(yùn)行該示例幾次并比較平均結(jié)果。在這種情況下，我們可以看到要素的最佳子集涉及索引[2、3、4]處的要素，這些要素的平均分類精度約為83.0％，這比以前使用所有輸入要素報(bào)告的結(jié)果要好。

>f([0,?1,?2,?3,?4])?=?0.813667
>f([0,?1,?2,?3])?=?0.827667
>f([0,?1,?2,?4])?=?0.815333
>f([0,?1,?2])?=?0.824000
>f([0,?1,?3,?4])?=?0.821333
>f([0,?1,?3])?=?0.825667
>f([0,?1,?4])?=?0.807333
>f([0,?1])?=?0.817667
>f([0,?2,?3,?4])?=?0.830333
>f([0,?2,?3])?=?0.819000
>f([0,?2,?4])?=?0.828000
>f([0,?2])?=?0.818333
>f([0,?3,?4])?=?0.830333
>f([0,?3])?=?0.821333
>f([0,?4])?=?0.816000
>f([0])?=?0.639333
>f([1,?2,?3,?4])?=?0.823667
>f([1,?2,?3])?=?0.821667
>f([1,?2,?4])?=?0.823333
>f([1,?2])?=?0.818667
>f([1,?3,?4])?=?0.818000
>f([1,?3])?=?0.820667
>f([1,?4])?=?0.809000
>f([1])?=?0.797000
>f([2,?3,?4])?=?0.827667
>f([2,?3])?=?0.755000
>f([2,?4])?=?0.827000
>f([2])?=?0.516667
>f([3,?4])?=?0.824000
>f([3])?=?0.514333
>f([4])?=?0.777667
Done!
f([0,?3,?4])?=?0.830333

現(xiàn)在，我們知道了如何枚舉所有可能的特征子集，讓我們看一下如何使用隨機(jī)優(yōu)化算法選擇特征子集。

優(yōu)化特征子集

我們可以將隨機(jī)優(yōu)化算法應(yīng)用于輸入特征子集的搜索空間。首先，讓我們定義一個更大的問題，該問題具有更多功能，這會使模型評估速度太慢，并且搜索空間太大，無法枚舉所有子集。我們將定義一個具有10,000行和500個輸入要素的分類問題，其中10個是相關(guān)的，其余490個是多余的。

#?define?a?large?classification?dataset
from?sklearn.datasets?import?make_classification
#?define?dataset
X,?y?=?make_classification(n_samples=10000,?n_features=500,?n_informative=10,?n_redundant=490,?random_state=1)
#?summarize?the?shape?of?the?dataset
print(X.shape,?y.shape)

運(yùn)行示例將創(chuàng)建數(shù)據(jù)集并確認(rèn)其具有所需的形狀。

(10000,?500)?(10000,)

我們可以通過評估具有所有輸入特征的數(shù)據(jù)集上的模型來建立性能基準(zhǔn)。由于數(shù)據(jù)集很大且模型評估緩慢，因此我們將修改模型的評估，以使用3倍交叉驗(yàn)證，例如更少的褶皺，沒有重復(fù)。下面列出了完整的示例。

#?evaluate?a?decision?tree?on?the?entire?larger?dataset
from?numpy?import?mean
from?numpy?import?std
from?sklearn.datasets?import?make_classification
from?sklearn.model_selection?import?cross_val_score
from?sklearn.model_selection?import?StratifiedKFold
from?sklearn.tree?import?DecisionTreeClassifier
#?define?dataset
X,?y?=?make_classification(n_samples=10000,?n_features=500,?n_informative=10,?n_redundant=490,?random_state=1)
#?define?model
model?=?DecisionTreeClassifier()
#?define?evaluation?procedure
cv?=?StratifiedKFold(n_splits=3)
#?evaluate?model
scores?=?cross_val_score(model,?X,?y,?scoring='accuracy',?cv=cv,?n_jobs=-1)
#?report?result
print('Mean?Accuracy:?%.3f?(%.3f)'?%?(mean(scores),?std(scores)))

運(yùn)行示例將評估整個數(shù)據(jù)集上的決策樹，并報(bào)告均值和標(biāo)準(zhǔn)差分類準(zhǔn)確性。

注意：由于算法或評估程序的隨機(jī)性，或者數(shù)值精度不同，您的結(jié)果可能會有所不同。考慮運(yùn)行該示例幾次并比較平均結(jié)果。在這種情況下，我們可以看到該模型的準(zhǔn)確度約為91.3％。這提供了使用功能選擇我們預(yù)期會勝過的基準(zhǔn)。

Mean?Accuracy:?0.913?(0.001)

我們將使用簡單的隨機(jī)爬山算法作為優(yōu)化算法。首先，我們必須定義目標(biāo)函數(shù)。它將數(shù)據(jù)集和要素子集用作輸入，并返回估計(jì)的模型準(zhǔn)確度，范圍從0（最差）到1（最佳）。這是一個最大化的優(yōu)化問題。這個目標(biāo)函數(shù)只是對上一節(jié)中序列和模型評估步驟的解碼。下面的Objective（）函數(shù)實(shí)現(xiàn)了此目的，并返回了得分和用于幫助報(bào)告的列的已解碼子集。

#?objective?function
def?objective(X,?y,?subset):
?#?convert?into?column?indexes
?ix?=?[i?for?i,?x?in?enumerate(subset)?if?x]
?#?check?for?now?column?(all?False)
?if?len(ix)?==?0:
??return?0.0
?#?select?columns
?X_new?=?X[:,?ix]
?#?define?model
?model?=?DecisionTreeClassifier()
?#?evaluate?model
?scores?=?cross_val_score(model,?X_new,?y,?scoring='accuracy',?cv=3,?n_jobs=-1)
?#?summarize?scores
?result?=?mean(scores)
?return?result,?ix

我們還需要一個可以在搜索空間中邁出一步的函數(shù)。給定一個現(xiàn)有的解決方案，它必須對其進(jìn)行修改并返回一個新的解決方案。在這種情況下，我們將通過隨機(jī)翻轉(zhuǎn)子序列中列的包含/排除來實(shí)現(xiàn)此目的。序列中的每個位置都將被獨(dú)立考慮，并且在翻轉(zhuǎn)的概率為超參數(shù)的情況下，概率將被翻轉(zhuǎn)。下面的mutate（）函數(shù)在給定的候選解決方案（布爾序列）和突變超參數(shù)的情況下實(shí)現(xiàn)了這一點(diǎn)，創(chuàng)建并返回了修改后的解決方案（搜索空間中的步驟）。p_mutate值越大（在0到1的范圍內(nèi)），搜索空間中的步長越大。

#?mutation?operator
def?mutate(solution,?p_mutate):
?#?make?a?copy
?child?=?solution.copy()
?for?i?in?range(len(child)):
??#?check?for?a?mutation
??if?rand()????#?flip?the?inclusion
???child[i]?=?not?child[i]
?return?child

現(xiàn)在，我們可以實(shí)現(xiàn)爬山算法。初始解決方案是隨機(jī)生成的序列，然后對其進(jìn)行評估。

#?generate?an?initial?point
solution?=?choice([True,?False],?size=X.shape[1])
#?evaluate?the?initial?point
solution_eval,?ix?=?objective(X,?y,?solution)

然后，我們循環(huán)進(jìn)行固定次數(shù)的迭代，創(chuàng)建當(dāng)前解決方案的變異版本，對其進(jìn)行評估，并在分?jǐn)?shù)更高時保存它們。

#?run?the?hill?climb
for?i?in?range(n_iter):
?#?take?a?step
?candidate?=?mutate(solution,?p_mutate)
?#?evaluate?candidate?point
?candidate_eval,?ix?=?objective(X,?y,?candidate)
?#?check?if?we?should?keep?the?new?point
?if?candidate_eval?>=?solution_eval:
??#?store?the?new?point
??solution,?solution_eval?=?candidate,?candidate_eval
?#?report?progress
?print('>%d?f(%s)?=?%f'?%?(i+1,?len(ix),?solution_eval))

下面的hillclimbing（）函數(shù)以數(shù)據(jù)集，目標(biāo)函數(shù)和超參數(shù)作為參數(shù)來實(shí)現(xiàn)此目的，并返回?cái)?shù)據(jù)集列的最佳子集和模型的估計(jì)性能。

#?hill?climbing?local?search?algorithm
def?hillclimbing(X,?y,?objective,?n_iter,?p_mutate):
?#?generate?an?initial?point
?solution?=?choice([True,?False],?size=X.shape[1])
?#?evaluate?the?initial?point
?solution_eval,?ix?=?objective(X,?y,?solution)
?#?run?the?hill?climb
?for?i?in?range(n_iter):
??#?take?a?step
??candidate?=?mutate(solution,?p_mutate)
??#?evaluate?candidate?point
??candidate_eval,?ix?=?objective(X,?y,?candidate)
??#?check?if?we?should?keep?the?new?point
??if?candidate_eval?>=?solution_eval:
???#?store?the?new?point
???solution,?solution_eval?=?candidate,?candidate_eval
??#?report?progress
??print('>%d?f(%s)?=?%f'?%?(i+1,?len(ix),?solution_eval))
?return?solution,?solution_eval

然后，我們可以調(diào)用此函數(shù)并傳入我們的綜合數(shù)據(jù)集以對特征選擇進(jìn)行優(yōu)化。在這種情況下，我們將對算法進(jìn)行100次迭代，并對給定突變的序列進(jìn)行約五次翻轉(zhuǎn)，這是非常保守的。

#?define?dataset
X,?y?=?make_classification(n_samples=10000,?n_features=500,?n_informative=10,?n_redundant=490,?random_state=1)
#?define?the?total?iterations
n_iter?=?100
#?probability?of?including/excluding?a?column
p_mut?=?10.0?/?500.0
#?perform?the?hill?climbing?search
subset,?score?=?hillclimbing(X,?y,?objective,?n_iter,?p_mut)

在運(yùn)行結(jié)束時，我們將布爾序列轉(zhuǎn)換為列索引（因此，如果需要，我們可以擬合最終模型），并報(bào)告最佳子序列的性能。

#?convert?into?column?indexes
ix?=?[i?for?i,?x?in?enumerate(subset)?if?x]
print('Done!')
print('Best:?f(%d)?=?%f'?%?(len(ix),?score))

結(jié)合在一起，下面列出了完整的示例。

#?stochastic?optimization?for?feature?selection
from?numpy?import?mean
from?numpy.random?import?rand
from?numpy.random?import?choice
from?sklearn.datasets?import?make_classification
from?sklearn.model_selection?import?cross_val_score
from?sklearn.tree?import?DecisionTreeClassifier
?
#?objective?function
def?objective(X,?y,?subset):
?#?convert?into?column?indexes
?ix?=?[i?for?i,?x?in?enumerate(subset)?if?x]
?#?check?for?now?column?(all?False)
?if?len(ix)?==?0:
??return?0.0
?#?select?columns
?X_new?=?X[:,?ix]
?#?define?model
?model?=?DecisionTreeClassifier()
?#?evaluate?model
?scores?=?cross_val_score(model,?X_new,?y,?scoring='accuracy',?cv=3,?n_jobs=-1)
?#?summarize?scores
?result?=?mean(scores)
?return?result,?ix
?
#?mutation?operator
def?mutate(solution,?p_mutate):
?#?make?a?copy
?child?=?solution.copy()
?for?i?in?range(len(child)):
??#?check?for?a?mutation
??if?rand()????#?flip?the?inclusion
???child[i]?=?not?child[i]
?return?child
?
#?hill?climbing?local?search?algorithm
def?hillclimbing(X,?y,?objective,?n_iter,?p_mutate):
?#?generate?an?initial?point
?solution?=?choice([True,?False],?size=X.shape[1])
?#?evaluate?the?initial?point
?solution_eval,?ix?=?objective(X,?y,?solution)
?#?run?the?hill?climb
?for?i?in?range(n_iter):
??#?take?a?step
??candidate?=?mutate(solution,?p_mutate)
??#?evaluate?candidate?point
??candidate_eval,?ix?=?objective(X,?y,?candidate)
??#?check?if?we?should?keep?the?new?point
??if?candidate_eval?>=?solution_eval:
???#?store?the?new?point
???solution,?solution_eval?=?candidate,?candidate_eval
??#?report?progress
??print('>%d?f(%s)?=?%f'?%?(i+1,?len(ix),?solution_eval))
?return?solution,?solution_eval
?
#?define?dataset
X,?y?=?make_classification(n_samples=10000,?n_features=500,?n_informative=10,?n_redundant=490,?random_state=1)
#?define?the?total?iterations
n_iter?=?100
#?probability?of?including/excluding?a?column
p_mut?=?10.0?/?500.0
#?perform?the?hill?climbing?search
subset,?score?=?hillclimbing(X,?y,?objective,?n_iter,?p_mut)
#?convert?into?column?indexes
ix?=?[i?for?i,?x?in?enumerate(subset)?if?x]
print('Done!')
print('Best:?f(%d)?=?%f'?%?(len(ix),?score))

運(yùn)行示例將報(bào)告所考慮特征的每個子集的模型的平均分類精度。然后在運(yùn)行結(jié)束時報(bào)告最佳子集。

注意：由于算法或評估程序的隨機(jī)性，或者數(shù)值精度不同，您的結(jié)果可能會有所不同。考慮運(yùn)行該示例幾次并比較平均結(jié)果。在這種情況下，我們可以看到，通過239個特征的子集和大約91.8％的分類精度，可以實(shí)現(xiàn)最佳性能。這比在所有輸入要素上評估的模型要好。盡管結(jié)果更好，但我們知道我們可以做得更好，可能是優(yōu)化優(yōu)化算法的超參數(shù)，或者是使用替代優(yōu)化算法。

>80?f(240)?=?0.918099
>81?f(236)?=?0.918099
>82?f(238)?=?0.918099
>83?f(236)?=?0.918099
>84?f(239)?=?0.918099
>85?f(240)?=?0.918099
>86?f(239)?=?0.918099
>87?f(245)?=?0.918099
>88?f(241)?=?0.918099
>89?f(239)?=?0.918099
>90?f(239)?=?0.918099
>91?f(241)?=?0.918099
>92?f(243)?=?0.918099
>93?f(245)?=?0.918099
>94?f(239)?=?0.918099
>95?f(245)?=?0.918099
>96?f(244)?=?0.918099
>97?f(242)?=?0.918099
>98?f(238)?=?0.918099
>99?f(248)?=?0.918099
>100?f(238)?=?0.918099
Done!
Best:?f(239)?=?0.918099