[深さ学習入門]バイナリ分類

do it! 深度学习入门课程を闻きながらメモをとる...

初期人工知能アルゴリズムと論理回帰

バイナリ分類はTrue(1)/False(0または-1)に区分される
yはstep関数(ステップ関数)
y=1(z>0の場合)、および-1
w_1 x_1 + w_2 x_2 + b = z
hat(y)からwとbスライスの計算を開始する

ろんりかいふく

論理回帰は分類アルゴリズムである.
中間はアクティブ化関数(activationfunction)によって計算される.線形方程式グループの値zで

0と1の間のaは、関数をアクティブにすることによって計算されます.
a>0.5
0.5より大きい場合は陽性であり、
a<=0.5
0.5未満の場合は音声クラス
信号関数はオズビーから始まる.
オズビー->ロッグ関数->タイムモードブート関数
確率=p/(1-p)(p:成功確率)
logit(p) = log(p/(1-p))
そして,ローグ関数を確率pの符号(sigmoid)関数(非書もある)に整理する.

整理すると、
線形方程式群の値を新しい結合で計算し,wとx特性の任意の値(−無限大から無限大のz値)を加えた.
この値が信号関数を通過すると、0と1の間の値に圧縮されます.臨界関数により,0.5を基準として音声/陽性カテゴリを判断し,バイナリ分類を実行する
aに基づいてアルゴリズムを実行して最適なwとbを検索する

対数損失関数を適用した傾斜降下法

分類の精度は微分関数です
バイナリクロスエントロピーまたは論理損失関数を使用します.
L = -(ylog(a) + (1-y)log(1-a))
y:目標値
a:アクティブ関数(=信号)関数の出力
陽性クラスではy=1,l=−log(a),aは1に近い
音声クラスの場合、y=0、l=-log(1-a)、aは0に近い
ターゲット値に似た値を持つ損失関数.
...
各ウェイトを微分計算すると...
b = b+(y-a)*1

バイナリ分類

論理回帰クラスを作成し、分類データを使用して悪性腫瘍を区別する分類モデルを作成する
サンプルデータセットの準備

from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
print(cancer.data.shape, cancer.target.shape)

#box Plot 그리기 
plt.boxplot(cancer.data)
plt.xlabel('feature')
plt.ylabel('value')
plt.show()

ブロック図によるデータ分布の決定
ほとんどはゼロに近い小さな値で構成されています.

小さい値もあれば、大きい値もあります.
データ規模範囲の違いがあります.
目標データを確認し、トレーニングデータを準備します.

np.unique(cancer.target, return_counts=True)

x = cancer.data
y = cancer.target

212個の陰性(=正常腫瘍)、357個の陽性(=悪性腫瘍)
陽性率は1.6〜7倍に達した.偏重

論理回帰用ニューロンの作成

一般化性能を評価するために,訓練群と試験群に分けた.
共有するルールはテストよりも多くの訓練が必要です.
トレーニングデータセットを分割する前に、トレーニングセットまたはテストセットのいずれかの側に集約されないように、陽性および陰性カテゴリを均一に混合する.
この例では、20%をテストとして使用します.

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, 
                                                    test_size=0.2, random_state=42)                                                    
# 분할 결과 확인 
print(x_train.shape, x_test.shape) #전체결과 20퍼 정도 

np.unique(y_train, return_counts=True) #음성 양성 클래스 비율을 유지 1.6정도 

実装ロジックユニット

前章のNeuronクラスに似ています

class LogisticNeuron:
    
    def __init__(self):
        self.w = None
        self.b = None

#정방향 계산 

    def forpass(self, x):
        z = np.sum(x * self.w) + self.b  # 직선 방정식을 계산합니다
        return z

#역방향 계산 

    def backprop(self, x, err):
        w_grad = x * err    # 가중치에 대한 그래디언트를 계산합니다
        b_grad = 1 * err    # 절편에 대한 그래디언트를 계산합니다
        return w_grad, b_grad

#시그모이드 함수 구현 

    def activation(self, z):
        z = np.clip(z, -100, None) # 안전한 np.exp() 계산을 위해
        a = 1 / (1 + np.exp(-z))  # 시그모이드 계산
        return a

#fit 메소드 구현 , 초기화는 1로 

    def fit(self, x, y, epochs=100):
        self.w = np.ones(x.shape[1])      # 가중치를 초기화합니다.
        self.b = 0                        # 절편을 초기화합니다.
        for i in range(epochs):           # epochs만큼 반복합니다
            for x_i, y_i in zip(x, y):    # 모든 샘플에 대해 반복합니다
                z = self.forpass(x_i)     # 정방향 계산
                a = self.activation(z)    # 활성화 함수 적용
                err = -(y_i - a)          # 오차 계산
                w_grad, b_grad = self.backprop(x_i, err) # 역방향 계산
                self.w -= w_grad          # 가중치 업데이트
                self.b -= b_grad          # 절편 업데이트

#각 원소에 대한 예측

    def predict(self, x):
        z = [self.forpass(x_i) for x_i in x]    # 정방향 계산
        a = self.activation(np.array(z))        # 활성화 함수 적용
        return a > 0.5

モデルトレーニングと結果確認

こらえた1嘘の0
一致するパーセンテージが表示され、結果は0.82です.
テスト例のパフォーマンスを確認できます

neuron = LogisticNeuron()
neuron.fit(x_train, y_train)

np.mean(neuron.predict(x_test) == y_test)

論理回帰ニューラルネットワークを用いて単層ニューラルネットワークを実現する

論理回帰を用いて単層ニューラルネットワークアルゴリズムを作成する
ロジャーズ回帰は最小のニューラルネットワーク単位と考えられる.
ロジス回帰の蓄積によってニューラルネットワークアルゴリズムを体現しても間違いない.
入力レイヤ、非表示レイヤ、出力レイヤ
1つ以上の非表示レイヤがある場合は、深度学習と呼ばれます.
ニューラルネットワークでは、アクティブ化関数は信号または他の
したがって、前に作成した内容を変更する必要はほとんどなく、簡単に実装するだけです.
追加するには、次の手順に従います.

損失関数の結果値を保存する機能の追加

傾斜降下法−損失関数の最小方向に学習するアルゴリズム.
したがって,損失関数値が反復とともに減少するかどうかを決定する必要がある.
loss保存リストを作成し、各epokeをリストに保存します.
現在の傾斜降下法は確率傾斜降下法ではない.△フォークごとにランダムに取り出す.
配置傾斜降下法ですべてのサンプルを選択できます
配置傾斜降下法は試料全体を用いたので,重み付け収束性が良好であることを示した.最適方向損失関数を探します.
確率傾斜降下法はデータセットが大きすぎる場合に用いられる.

この2つのスキームのトレードオフスキームはマイクロ配置傾斜降下法である。

ランダムにいくつか吸って、グリニッジを計算して、もうランダムに1つ吸って......
レイアウトよりも早くベストポイントに近づきます.
各フォークはトレーニングサンプルを混ぜなければならないのでindexを混ぜます.
イポックが開始されると、整数配列サイズでブレンドできます.

scoreメソッドを使用してカウント出力を正確に調整する

class SingleLayer:
    
    def __init__(self):
        self.w = None
        self.b = None
        self.losses = []

    def forpass(self, x):
        z = np.sum(x * self.w) + self.b  # 직선 방정식을 계산합니다
        return z

    def backprop(self, x, err):
        w_grad = x * err    # 가중치에 대한 그래디언트를 계산합니다
        b_grad = 1 * err    # 절편에 대한 그래디언트를 계산합니다
        return w_grad, b_grad

    def activation(self, z):
        z = np.clip(z, -100, None) # 안전한 np.exp() 계산을 위해
        a = 1 / (1 + np.exp(-z))  # 시그모이드 계산
        return a
        
    def fit(self, x, y, epochs=100):
        self.w = np.ones(x.shape[1])               # 가중치를 초기화합니다.
        self.b = 0                                 # 절편을 초기화합니다.
        for i in range(epochs):                    # epochs만큼 반복합니다
            loss = 0
            # 인덱스를 섞습니다
            indexes = np.random.permutation(np.arange(len(x)))
            for i in indexes:                      # 모든 샘플에 대해 반복합니다
                z = self.forpass(x[i])             # 정방향 계산
                a = self.activation(z)             # 활성화 함수 적용
                err = -(y[i] - a)                  # 오차 계산
                w_grad, b_grad = self.backprop(x[i], err) # 역방향 계산
                self.w -= w_grad                   # 가중치 업데이트
                self.b -= b_grad                   # 절편 업데이트
                # 안전한 로그 계산을 위해 클리핑한 후 손실을 누적합니다
                a = np.clip(a, 1e-10, 1-1e-10)
                loss += -(y[i]*np.log(a)+(1-y[i])*np.log(1-a))
            # 에포크마다 평균 손실을 저장합니다
            self.losses.append(loss/len(y))
    
    def predict(self, x):
        z = [self.forpass(x_i) for x_i in x]     # 정방향 계산
        return np.array(z) > 0                   # 스텝 함수 적용
    
    def score(self, x, y):
        return np.mean(self.predict(x) == y)

ループによる論理回帰

回帰はSGDRgressor
loss=「log」を使用してポインタ損失関数を指定

from sklearn.linear_model import SGDClassifier
sgd = SGDClassifier(loss='log', max_iter=100, tol=1e-3, random_state=42)

sgd.fit(x_train, y_train)
sgd.score(x_test, y_test)

sgd.predict(x_test[0:10])

ネットワーク全体の実行モデルで一貫した鍵管理api構造を維持
1つのモデルが適切に使用されている場合、他のモデルの方法も簡単に使用できます.
ただし、クラスごとに指定方法が異なりますので、よく見てください