Master

bp.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+"""
+bp.py 프로그램
+오차역전파법에 의한 계층형 신경망의 학습
+오차의 추이나 학습 결과가 되는 결합개수 등을 입력합니다.
+사용방법 : c:\>python bp.py
+"""
+
+# 모듈 가져오기 
+import math
+import sys
+import random
+
+# 글로벌 변수
+INPUTNO = 5         # 입력층의 뉴런 수 
+HIDDENNO = 3        # 은닉층의 뉴런 수
+OUTPUTNO = 5        # 출력층의 뉴런 수
+ALPHA = 10          # 학습 계수
+SEED = 65535        # 난수 시드
+MAXINPUTNO = 100    # 데이터의 최대 수
+BIGNUM = 100.0      # 오차의 초깃값
+LIMIT = 0.001       # 오차의 상한 값
+
+# 형식 인수의 정의
+# forward() 함수
+def forward(wh, wo, hi, e):
+    ''' 순방향 계산 '''
+    # hi의 계산
+    for i in range(HIDDENNO):
+        u = 0.0
+        for j in range(INPUTNO):
+            u += e[j] * wh[i][j]
+        u -= wh[i][INPUTNO]     # 임계값 처리
+        hi[i] = f(u)
+    # 출력 o의 계산
+    o = 0.0
+    for i in range(HIDDENNO):
+        o += hi[i] * wo[i]
+    o -= wo[HIDDENNO]           # 임계값 처리
+    return f(o)
+# forward() 함수 끝내기
+
+# f() 함수
+def f(u):
+    ''' 전이 함수 '''
+    # 시그모이드 함수의 계산 
+    return 1.0 / (1.0 + math.exp(-u))
+# f() 함수 끝내기
+
+# olearn() 함수
+def olearn(wo, hi, e, o, k):
+    ''' 출력층의 가중치 학습 '''
+    # 오차 계산
+    d = (e[INPUTNO + k] - o) * o * (1 - o)
+    # 가중치 학습
+    for i in range(HIDDENNO):
+        wo[i] += ALPHA * hi[i] * d
+    # 임계값 학습
+    wo[HIDDENNO] += ALPHA * (-1.0) * d
+    return
+# olearn() 함수 끝내기
+
+# hlearn() 함수
+def hlearn(wh, wo, hi, e, o, k):
+    ''' 은닉층의 가중치 학습 '''
+    # 은닉층의 각 셀 j를 대상
+    for j in range(HIDDENNO):
+        dj = hi[j] * ( 1 - hi[j]) * wo[j] * (e[INPUTNO + k] - o ) * o * (1 - o)
+        # i번째의 가중치를 처리
+        for i in range(INPUTNO):
+            wh[j][i] += ALPHA * e[i] * dj
+        # 임계값 학습
+        wh[j][INPUTNO] += ALPHA * ( -1.0) * dj
+    return
+# hlearn() 함수 끝내기
+
+
+# 메인 실행부
+# 난수의 초기화
+random.seed(SEED)
+
+# 번수의 준비
+wh = [[random.uniform(-1, 1) for i in range(INPUTNO + 1)]
+    for j in range(HIDDENNO)]       # 은닉층의 가중치
+wo = [[random.uniform(-1,1) for i in range(HIDDENNO + 1)]
+    for j in range(OUTPUTNO)]    # 출력층의 가중치
+hi = [0.0 for i in range(HIDDENNO + 1)] # 은닉층의 출력
+o = [0.0 for i in range(OUTPUTNO)]
+err = BIGNUM
+
+# 학습 데이터 세트
+e = [[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+     [ 0, 1, 0, 0, 0, 0, 1, 0, 0, 0],
+     [ 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
+     [ 0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+     [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]]
+
+n_of_e = len(e)
+
+# 결합하중의 초깃값 출력
+print(wh, wo)
+
+# 학습
+count = 0
+while err > LIMIT:
+    # 복수의 출력층에 대응
+    for k in range(OUTPUTNO):
+        err = 0.0
+        for j in range(n_of_e):
+            # 순방향 계산
+            o[k] = forward(wh, wo[k], hi, e[j])
+            # 출력층의 가중치 조정
+            olearn(wo[k], hi, e[j], o[k], k)
+            # 은닉층의 가중치 조정
+            hlearn(wh, wo[k], hi, e[j], o[k], k)
+            # 오차의 합산
+            teacherno = INPUTNO + k
+            err += (o[k] - e[j][teacherno]) * ( o[k] - e[j][teacherno])
+        count += 1
+        # 오차의 출력
+        print(count, " ", err)
+# 결합 하중의 출력
+print(wh, wo)
+
+# 학습 데이터에 대한 출력
+for i in range(n_of_e):
+    print(i)
+    print(e[i])
+    outputlist = []
+    for j in range(OUTPUTNO):
+        outputlist.append(forward(wh, wo[j], hi, e[i]))
+    print(['{:.3f}'.format(num) for num in outputlist])
+# bp.py 끝내기

doctor.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""
+
+doctor.py 프로그램
+간단히 작성한 ELIZA 프로그램 
+사용방법 : c:\>python doctor.py
+
+"""
+
+# 모듈 가져오기 
+import re
+
+# 초기 설정
+LIMIT = 20      # 최소 횟수
+CYCLE = 5       # 반복 횟수
+
+# 메인 실행부 
+count = 0
+endcount = 0
+
+print("Dr> 나는 Doctor. 이야기를 들어볼까요?")
+while True:      # 1 행마다 패턴을 조사해서 응답한다.
+    inputline = input("당신>")
+    if count >= CYCLE:      # 반복
+        print("Dr> ", inputline, "입니까...")
+        count = 0
+    elif re.search("선생님", inputline):
+        print("Dr> 내가 아닌 당신에 관한 이야기를 합시다.")
+    elif re.search("어머니", inputline):
+        print("Dr> 당신의 어머니에 대해 이야기해주세요.")
+    elif re.search("아버지", inputline):
+        print("Dr> 당신의 아버지에 대해 이야기해주시요.")
+    elif re.search("의견", inputline):
+        print("Dr> 내 의견을 듣고 싶은 겁니까?")
+    elif re.search("이 걱정입니다", inputline):
+        print("Dr> ", inputline.replace("이 걱정입니다", "가 걱정입니까?"))
+    else :
+        print("Dr> 계속해보세요")
+    count += 1
+    endcount += 1
+    if endcount >= LIMIT:
+        break
+print("Dr> 그러면 여기서 마칩시다. 수고하셨습니다.")
+
+# doctor.py 끝내기
+

filter.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+filter.py 프로그램
+공간 필터 적용
+2차원 데이터를 읽어내고 공간 필터를 적용한다
+사용 방법 : c:\>python filter.py
+"""
+
+# 모듈 가져오기 
+import math
+import sys
+
+# 글로벌 변수 
+INPUTSIZE = 11      # 입력 수
+
+# 형식 인수의 정의
+# getdata() 함수
+def getdata(im):
+    """ 이미지 데이터 읽어오기 """
+    n_of_e = 0      # 데이터 세트의 행 수
+    # 데이터 입력
+    for line in sys.stdin:
+        im[n_of_e] = [float(num) for num in line.split()]
+        n_of_e += 1
+    return 
+# getdata() 함수 끝내기
+
+# filtering() 함수
+def filtering(filter, im, im_out):
+    """ 필터 적용 """
+    for i in range(1, INPUTSIZE - 1):
+        for j in range(1, INPUTSIZE - 1):
+            im_out[i][j] = calcfilter(filter, im, i, j)
+    return
+# filtering() 함수 끝내기 
+
+# calcfilter() 함수
+def calcfilter(filter, im, i, j):
+    """ 필터 적용 """
+    sum = 0.0
+    for m in range(3):
+        for n in range(3):
+            sum += im[i - 1 + m][j - 1 + n] * filter[m][n]
+    if sum < 0:     # 결과가 마이너스일 경우는 0으로 한다
+        sum = 0
+    return sum
+# calcfilter() 함수 끝내기 
+
+# 메인 실행부 
+np = 1.0 / 9.0
+
+filter = [[0, 1, 0], [1, -4, 1], [0, 1, 0]]     # 라플라시안 필터
+# filter = [[ np, np, np], [np, np, np], [np, np, np]]  # 평균필터
+
+im = [[0.0 for i in range(INPUTSIZE)]
+    for j in range(INPUTSIZE)]                  # 입력 데이터
+im_out = [[0.0 for i in range(INPUTSIZE)]
+    for j in range(INPUTSIZE)]                  # 출력 이미지
+
+# 입력 데이터 읽어오기 
+getdata(im)
+
+# 필터 적용
+filtering(filter, im, im_out)
+
+# 결과 출력
+for i in im_out:
+    for j in i:
+        print("{:3f} ".format(j), end="")
+    print()
+
+# filter.py 끝내기
+
+

input_image.txt

@@ -0,0 +1,8 @@
+00000000
+03004050
+00000000
+22222222
+11111111
+00000000
+30701030
+06050103

isa.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+"""
+isa.py 프로그램
+is-a 링크에 의한 의미 네트워크를 이용한 추론
+사용 방법 : c:\>python isa.py
+"""
+
+
+# 의미 네트워크의 정의
+semnet = { 
+    "휴대단말기"    : "컴퓨터",
+    "노트북"        : "컴퓨터",
+    "거치형 PC"     : "컴퓨터",
+    "스마트폰"      : "휴대단말기",
+    "태블릿"        : "휴대단말기",
+    "데스크톱"      : "거치형 PC",
+    "서버"          : "거치형 PC",
+}
+
+# 메인 실행부
+while True:
+    # 분류 대상 입력
+    print("A는 B입니까? 라는 질문을 다룹니다. A와 B를 입력하세요")
+    A = input("A를 입력: ")
+    B = input("B를 입력: ")
+    print("질문: ", A, "는 ", B, "입니까?")
+    print("추론을 시작합니다.")
+    # A가 의미 네트워크를 포함하지 않는다면 종료
+    if (A in semnet) == False:
+        print("'", A, "'", "를 모릅니다.")
+        continue
+    # is-a 링크를 따라가면서 B를 찾는다
+    obj = A
+    while obj != B:
+        print(" ", obj, "는 ", semnet[obj], "입니다.")
+        if semnet[obj] == B:
+            print("결론: ", A, "는 ", B, "입니다.")
+            break
+        if(semnet[obj] in semnet) == False:
+            print("결론: ", A, "는 ", B, "가 아닙니다.")
+            break
+        obj = semnet[obj]
+    print("추론 종료.")
+# isa.py 끝내기

kneighbor.py

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+"""
+kneighbor.py 프로그램
+K-인접기법 계산 프로그램
+사용방법 : c:\>python kneighbor.py
+"""
+
+# 메인 실행부
+# 학습 데이터 세트의 정의
+itemdata = [ [ 30, 50, "A"], [ 65, 40, "B"],
+            [ 90, 100, "A"], [ 90, 60, "B"],
+            [ 70, 60, "B"], [ 40, 50, "A"],
+            [ 80, 50, "B"]]
+
+#분류 대상 입력
+h = float(input("분류 대사을 입력하세요:"))
+a = float(input("분류 대상의 상부 표면 면적을 입력하세요:"))
+
+#리스트 정렬
+itemdata.sort(key = lambda x : (x[0] - h) ** 2 + (x[1] - a) ** 2)
+
+#결과 출력
+print(itemdata)
+
+#kneighbor.py 끝내기

morph.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+morph.py 프로그램
+정규표현을 이용한 간단한 형태소 분리 프로그램
+사용방법 : c:\>python morph.py
+"""
+
+# 모듈 가져오기
+import re
+
+# 형식 인수의 정의
+# whatch() 함수
+def whatch(ch):
+    """ 글자 종류의 판정 """
+    if re.match('[가-횧]+', ch):
+        chartype = 0
+    elif re.match('[A-Za_z]+',ch):
+        chartype = 1
+    elif re.match('[0-9]+', ch):
+        chartype = 2
+    else:
+        chartype = 3
+    return chartype
+# whatch() 함수 끝내기
+
+# 메인 실행부
+# 분석 대상 문자열의 설정
+inputtext = "TOTAL합계120000원입니다."
+# 띄어쓰기 문장의 생성
+outputtext = ""
+for i in range(len(inputtext) - 1):
+    print(inputtext[i], end = "")
+    if whatch(inputtext[i]) != whatch(inputtext[i + 1]):
+        print(" ", end = "")
+print(inputtext[-1:])
+# morph.py 끝내기
+
+
+
+