<jupyter_start><jupyter_text>Transfer function types 구글 번역 google translate신경망의 학습 특성은 단 변량 선형 분류 자의 유일한 도움으로 그다지 크지 않을 것입니다. 약간의 복잡한 문제 sin 기계 학습조차도 여러 비선형 변수를 포함하므로 Perceptron의 전달 함수를 대체하는 많은 변형이 개발되었습니다.비선형 모델을 나타 내기 위해 활성화 함수에는 여러 가지 다른 비선형 함수를 사용할 수 있습니다. 이것은 뉴런이 입력 변수의 변화에 ​​반응하는 방식의 변화를 의미합니다. 다음 섹션에서는 주요 전달 함수를 정의하고 코드를 통해이를 정의하고 표현할 것입니다.이 절에서는 문제 영역의 엔티티를 나타 내기 위해 Python의 객체 지향 프로그래밍을 사용하기 시작합니다. 예제를 통해 훨씬 명확한 방식으로 개념을 표현할 수 있습니다.클래스 유형에 의해 결정되는 활성화 함수를 반환하는 getTransferFunction (x)과 그 파생물을 명확하게 반환하는 getTransferFunctionDerivative (x)라는 두 가지 메소드가 포함 된 TransferFunction 클래스를 만들어 보겠습니다. 두 함수 모두 입력은 Numpy 배열이 될 것이고, 함수는 요소별로 적용될 것입니다.<jupyter_code># TransferFunction이란 이름의 class 생성
class TransferFunction:
    # getTransferFunction이란 이름의 함수 생성, 인자값으로 x를 받음
    def getTransferFunction(x):
        # 오류를 강제로 발생시킨다, 위의 함수를 구현해야 오류가 발생하지 않는다
        # 파이썬 내장 오류로, 꼭 작성해야 하는 부분이 구현되지 않았을 경우 일부러 오류를 발생시키고자 사용한다.
        raise NotImplementedError
    # getTransferFunctionDerivative이란 이름의 함수 생성, 인자값으로 x를 받음
    def getTransferFunctionDerivative(x):
        raise NotImplementedError<jupyter_output><empty_output><jupyter_text>Representing and understanding the transfer functions<jupyter_code># graphTransferFunction이란 이름의 함수 생성, 인자값으로 function를 받음
def graphTransferFunction(function):
    # numpy 배열생성 -2~ 2 까지 0.01 씩 올려서
    x = np.arange(-2.0, 2.0, 0.01)
    # plot에 보여주는 width : 18 , height: 8 로 설정
    plt.figure(figsize=(18,8))
    # plot 의 subplot 생성 121
    ax=plt.subplot(121)
    # ax subplot 의 이름을 function의 이름으로 설정
    ax.set_title(function.__name__)
    # plot에 function.getTransferFunction의 함수 실행후 화면 출력
    # 아래 Class의 Function이름 을 사용
    plt.plot(x, function.getTransferFunction(x))
    # plot 의 subplot 생성 122
    ax=plt.subplot(122)
    # ax subplot 의 이름을 function의 'Derivative of 이름'으로 설정
    ax.set_title('Derivative of ' + function.__name__)
    # plot에 function.getTransferFunctionDerivative의 함수 실행후 화면 출력
    # 아래 Class의 Function이름 을 사용
    plt.plot(x, function.getTransferFunctionDerivative(x))<jupyter_output><empty_output><jupyter_text>Sigmoid or Logistic function 구글 번역 google translate표준화 된 활성화 함수이며 분류 속성에서 확률을 계산할 때 매우 좋은 특성을 갖습니다.  먼저 -2.0에서 2.0까지의 공통 범위에서 파생 함수로 모든 전달 함수를 그래프 화하는 데 사용할 함수를 준비하고 y 축을 중심으로 주요 특성을 볼 수있게합니다.  시그모이드의 고전 공식은 다음과 같습니다.<jupyter_code># Sigmoid이란 이름의 class 생성 , 인자값으로 TransferFunction을 받음
class Sigmoid(TransferFunction):  #Squash 0,1
    # getTransferFunction function 정의
    def getTransferFunction(x):
        return 1/(1+np.exp(-x))
    # getTransferFunctionDerivative function 정의
    def getTransferFunctionDerivative(x):
        return x*(1-x)
# 위에서 정의한 graphTransferFunction 을 사용
graphTransferFunction(Sigmoid)<jupyter_output><empty_output><jupyter_text>Playing with the Sigmoid다음으로 우리는 Sigmoid가 가중치에 의해 곱해 졌을 때 바이어스에 의해 어떻게 변하는 지에 대한 직감을 얻기 위해 마지막 함수를 최소화하도록 직관을 얻는 연습을 할 것입니다. 그런 다음 단일 시그 모이 드의 가능한 매개 변수를 먼저 변경하고 스트레치 및 이동을 봅니다.<jupyter_code># Numpy Array 배열 생성
# -1~ 1 까지 0.2 씩 올려서
ws=np.arange(-1.0, 1.0, 0.2)
bs=np.arange(-2.0, 2.0, 0.2)
xs=np.arange(-4.0, 4.0, 0.1)
# plot에 보여주는 width : 20 , height: 10 로 설정
plt.figure(figsize=(20,10))
# plot 의 subplot 생성 121
ax=plt.subplot(121)
# ws 배열 처음부터 끝까지 반복
for i in ws:
    # plot 에 xs 배열값을 Sigmoid class의 getTransferFunction 함수 실행 (인자값 i*xs)
    plt.plot(xs,  Sigmoid.getTransferFunction(i *xs),label= str(i));
ax.set_title('Sigmoid variants in w')
# plot의 legend 표시를 화면 상단 좌측에 표시
plt.legend(loc='upper left');
# plot 의 subplot 생성 122
ax=plt.subplot(122)
# bs 배열 처음부터 끝까지 반복
for i in bs:
    plt.plot(xs,  Sigmoid.getTransferFunction(i +xs),label= str(i));
ax.set_title('Sigmoid variants in b')
# plot의 legend 표시를 화면 상단 좌측에 표시
plt.legend(loc='upper left');
# Tanh이란 이름의 class 생성 , 인자값으로 TransferFunction을 받음
class Tanh(TransferFunction):  #Squash -1,1
    def getTransferFunction(x):
        # x값 tnah 처리하여 리턴 
        return np.tanh(x)
    def getTransferFunctionDerivative(x):
        # tanh 처리한 X값에 제곱 을 리턴
        return np.power(np.tanh(x),2)
# 위에서 정의한 graphTransferFunction 을 사용
graphTransferFunction(Tanh)<jupyter_output><empty_output><jupyter_text>Rectified linear unit or Relu 구글 번역 google translate이것을 정류된 선형 단위라고하며 그 주요 장점 중 하나는 일반적으로 0의 값을 가지거나 작은 엡실론 값을 갖는 네트워크의 첫 번째 계층으로 구성되는 소실성 그라디언트 문제의 영향을받지 않는다는 것입니다<jupyter_code>class Relu(TransferFunction):
    def getTransferFunction(x):
        # x값이 0보다 클때만 x 값 리턴
        return x * (x>0)
    def getTransferFunctionDerivative(x):
        # x값이 0보다 클때만 1 리턴
        return 1 * (x>0)
graphTransferFunction(Relu)<jupyter_output><empty_output><jupyter_text>Defining loss functions for Neural Networks 구글 번역 google translateMachine Learning의 모든 모델에서 우리는 예측과 분류가 얼마나 잘되었는지를 결정하는 데 사용할 수있는 기능을 탐색합니다.  이 책에서 할 첫 번째 유형의 구분은 L1과 L2 오류 기능 유형 사이입니다.L1은 최소 절대 편차 (LAD) 또는 최소 절대 오차 (LAE)로도 알려져 있으며 매우 흥미로운 특성을 가지고 있으며 모델의 최종 결과와 예상 값의 절대 차이만으로 구성됩니다.L2는 MSE(Mean of Squared Error) 이다L1 과 L2의 유형 말고 크로스 엔트로피란 손실함수가 존재한다. 기본적으로 L2와 크로스 엔트로피 손실함수를 사용  하지만 본 프로젝트에서는 L1과 L2를 주제로 신경망의 손실함수에 대해 기술 함 L1 vs L2 compared properties RobustnessL1은 L2에 비해 매우 강력한 손실 함수이며, 함수의 이상치에 영향을받는 것에 대한 저항으로 표현 될 수 있습니다.  이 함수는 2 차 함수를 매우 높은 값으로 투영합니다. 따라서 L2 기능을 선택하기 위해서는 효율성을 높이기 위해 매우 엄격한 데이터를 사용해야합니다. Stability안정성 속성은 큰 값에 대해 오차 곡선이 얼마나 많이 점프 하는지를 평가합니다.  L1은 불안정합니다. 특히 정규화되지 않은 데이터 세트의 경우 ([-1, 1] 범위의 숫자가 제곱시 작아지기 때문에) Solution uniqueness그것의 2 차 특성에 의해 추론 될 수 있듯이, L2 함수는 최소값에 대한 우리의 탐색에 대한 유일한 해답을 보장합니다.  L2는 항상 유일한 해법을 가지고 있지만, L1의 경우에는 단선 거리와 비교하여 조각 별 선형 함수의 형태로 우리 모델에 많은 minimun distance 방법을 찾을 수 있기 때문에 L1은 그 중 많은 것을 가질 수 있습니다.사용에 관해서는, 과거 속성의 합계는 우리가 L2 오류 유형을 사용하는 정상적인 경우, 특히 솔루션 단일성 (solution unicity) 때문에 오류 값을 최소화하기 시작할 때 필요한 확실성을 얻을 수있게 해줍니다.  첫번쨰 예제에서 우리는 교육 목적을 위해보다 간단한 L1 오류 functin으로 시작할 것입니다.샘플 L1 및 L2 손실 오류 함수에 대한 오류 결과를 그래프로 표시하여 이러한 두 가지 접근법을 살펴 보겠습니다.  다음의 간단한 예에서는 두 가지 오류의 매우 다른 특성을 보여줍니다. 처음 두 예제에서는 정규화 된 입력 (-1과 1 사이)과 그 범위를 벗어난 값을 보여줍니다.  알 수 있듯이 샘플 0에서 3까지 2 차 오차는 꾸준히 증가하지만 연속적으로 증가하지만 정규화되지 않은 데이터의 경우에는 특히 이상치 및 비 정규화 된 데이터로 폭발 할 수 있습니다.<jupyter_code># Numpy array 생성 임의의 값
sampley_=np.array([.1,.2,.3,-.4, -1, -3, 6, 3])
# Numpy array 생성 임의의 값
sampley=np.array([.2,-.2,.6,.10, 2, -1, 3, -1])

ax.set_title('Sigmoid variants in b')
plt.figure(figsize=(10,10))
ax=plt.subplot()
plt.plot(sampley_ - sampley, label='L1')
plt.plot(np.power((sampley_ - sampley),2), label="L2")
ax.set_title('L1 vs L2 initial comparison')
plt.legend(loc='best')
plt.show()<jupyter_output><empty_output><jupyter_text>LossFunction 클래스의 형식으로 손실 함수를 정의하고 L1 및 L2 손실 함수 유형의 getLoss 메서드는 두 개의 NumpyArrays를 매개 변수, y_ 또는 예상 함수 값, y를 예상 값으로받습니다.<jupyter_code># class 정의 하고
class LossFunction:
    # getLoss 함수를 추상화 하여 필수적으로 구현하게 NotImplementedError 에러 발생 
    def getLoss(y_ , y ):
        raise NotImplementedError
# L1 클래스 정의        
class L1(LossFunction):
    # getLoss 함수 정의
    # L1 알고리즘 구현
    def getLoss(y_, y):
        return np.sum (y_ - y)
# L2 클래스 정의        
class L2(LossFunction):
    # getLoss 함수 정의
    # L2 알고리즘 구현
    def getLoss(y_, y):
        return np.sum (np.power((y_ - y),2))<jupyter_output><empty_output><jupyter_text>이제 목표 함수를 정의 할 시간입니다. 우리는이를 단순한 부울 함수로 정의 할 것입니다.  더 빠른 수렴성을 가능하게하려면 첫 번째 입력 변수와 함수 결과 사이에 직접적인 관계가 있습니다<jupyter_code># input dataset
X = np.array([  [0,0,1],
                [0,1,1],
                [1,0,1],
                [1,1,1] ])
    
# output dataset            
y = np.array([[0,0,1,1]]).T<jupyter_output><empty_output><jupyter_text>우리가 사용할 첫 번째 모델은 모델의 복잡성을 최소한으로 유지하기 위해 바이어스없이 각 셀에 3 개의 셀이있는 아주 최소한의 신경망입니다.<jupyter_code># 가중치 W 평균 0 으로 가중치를 랜덤하게 초기화
W = 2*np.random.random((3,1)) - 1
print (W)<jupyter_output>[[-0.48917749]
 [ 0.16321445]
 [ 0.97039715]]<jupyter_text>그런 다음 모델 오류, 가중치 및 학습 결과 진행을 수집하기위한 변수 집합을 정의합니다.<jupyter_code># 배열을 생성하고 특정한 값으로 초기화를 하지 않는 방식
# 들어있는 값은 기존 메모리에 저장되어있는 값으로 쓰레기값
errorlist=np.empty(3);
print(errorlist)
# Numpy Array 생성
weighthistory=np.array(0)
print(weighthistory)
resultshistory=np.array(0)
print(weighthistory)<jupyter_output>[0.48917749 0.16321445 0.97039715]
0
0<jupyter_text>그런 다음 iterative error minimization을 할 차례입니다. 이 경우에는 가중치와 뉴런의 전달 함수를 통해 전체 실제 테이블의 100 배를 공급하여 오류 방향으로 가중치를 조정합니다.  이 모델은 학습 속도를 사용하지 않으므로 빠르게 수렴 (또는 분기)해야합니다.<jupyter_code>for iter in range(100):
    # 전방향 전파
    l0 = X
    # 1/1+exp(-x)
    # np.dot : 요소별 곱셈의 합 [ [ l0[0,0]*W[0]+l0[0,1]*W[1]+l0[0,2]*W[2] ] , 
    #                                           [l0[1,0]*W[0]+l0[1,1]*W[1]+l0[1,2]*W[2] ] ,
    #                                             .....]
    l1 = Sigmoid.getTransferFunction(np.dot(l0,W))
    resultshistory = np.append(resultshistory , l1)

    # 오차 계산
    l1_error = y - l1
    errorlist=np.append(errorlist, l1_error)
    
    # 역전파 1: Get the deltas
    l1_delta = l1_error * Sigmoid.getTransferFunctionDerivative(l1)

    # 가중치 조정
    W += np.dot(l0.T,l1_delta)
    weighthistory=np.append(weighthistory,W)<jupyter_output><empty_output><jupyter_text>L1에서 출력 값을 인쇄하는 것으로부터의 마지막 평가 단계를 간단히 살펴 보겠습니다. 이제 문자 그대로 원래 함수의 결과를 반영하고 있음을 알 수 있습니다.<jupyter_code>print (l1)<jupyter_output>[[0.11947425]
 [0.09264386]
 [0.92628991]
 [0.90436495]]<jupyter_text>프로세스를 더 잘 이해하려면 매개 변수가 시간에 따라 어떻게 변하는 지 살펴보십시오. 먼저 뉴런의 무게를 그래프로 나타냅니다  : 무작위 상태에서 첫 번째 열 (항상 오른쪽)의 전체 값을 받아들이고 두 번째 열은 거의 0이됩니다 (두 번째 열의 오른쪽 50 %입니다). 시간), 세 번째로 -2로 이동합니다 (주로 테이블의 처음 두 요소에서 0을 트리거하기 때문에)<jupyter_code># plot width 20 , height 20 설정
plt.figure(figsize=(20,20))
print (W)
#  imshow는 행렬데이터를 그림으로 표현하는것, cmap : 그림표현 컬러 지정, interpolation : 두점을 연결하는 방법 (https://iskim3068.tistory.com/35)
# 가중치의 변화량 (weighthistory)
plt.imshow(np.reshape(weighthistory[1:],(-1,3))[:40], cmap=plt.cm.gray_r, interpolation='nearest');<jupyter_output>[[ 4.54177   ]
 [-0.28387039]
 [-2.00447068]]<jupyter_text>마지막으로 도달 할 때까지 솔루션이 진화하는 방식 (처음 40 회 반복)을 검토하여 이상적인 값으로의 수렴성을 명확하게 볼 수 있습니다.<jupyter_code>plt.figure(figsize=(20,20))
# 결과값의 변화량 (resultshistory)
plt.imshow(np.reshape(resultshistory[1:], (-1,4))[:40], cmap=plt.cm.gray_r, interpolation='nearest');<jupyter_output><empty_output><jupyter_text>그런 다음 에러레브르 (errorevolves)와 다른 에포크 (epoques)를 통해 제로가되는 경향을 볼 수 있습니다. 이 경우 우리는 처음에 L1 오류 기능을 사용했기 때문에 그 가능성을 갖는 음수에서 양수로 그것의 흔들림 상태를 관찰 할 수 있습니다.<jupyter_code>plt.figure(figsize=(10,10))
# plot으로 errorList를 볼수있다
# 학습이 진행됨에 따라 오차가 줄어드는것을 볼수있다
plt.plot(errorlist);<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0950465914664051, 'fraction_numerical': 0.037861696910250126, 'mean_word_length': 3.5095090667846085, 'pattern_counts': {'":': 0, '<': 57, '<?xml version=': 0, '>': 59, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '15', 'dir': 'jupyter-structured-clean-dedup', 'id': '269158', 'license': 'MIT', 'n_tokens_mistral': 6675, 'n_tokens_neox': 7994, 'n_words': 1387, 'path': 'Chapter05/Ch5.ipynb', 'repo_name': 'Limdh3325/Machine-Learning-for-Developers', 'size': '10195'}