반응형

오늘은 파이썬(Python) 파이토치(PyTorch)에서 자연어를

처리하기 위해서 우선적으로 해야 할 토큰 만들기를 알아보겠습니다.

자연어를 처리하기 위해서는 단어를 구분해서

문장을 해석해야 합니다.

 

간단하게 문장과 공백으로도 나눌 수 있지만

정확한 의미를 확인하기 위해서는 문장과 공백만을

구분해서는 사용하기 힘듭니다.

 

NLP 작업에 사용되는 말뭉치(corpus)는 원시 텍스트와

메타데이터로 구성됩니다.

원시 텍스트, 메타데이터를 구분하기 위해서

오픈 소스 NLP 패키지는 대부분 코큰화 기능을 지원합니다.

대표적인 NLP 두가지 제품을 사용해서 토큰화를 확인해보겠습니다.

 

첫 번째 오픈 NLP 패키지 spacy

https://spacy.io/

 

spaCy · Industrial-strength Natural Language Processing in Python

spaCy is a free open-source library for Natural Language Processing in Python. It features NER, POS tagging, dependency parsing, word vectors and more.

spacy.io

spacy를 사용하기 위해서는 먼저 패키지를 설정해야 합니다.

spacy는 패키지 설치 시간이 조금 오래 걸립니다.

import spacy

import를 사용해서 spacy 패키지를 로드합니다.

def spacyex():
    nlp = spacy.load('en_core_web_sm')

    # Process whole documents
    text = ("When Sebastian Thrun started working on self-driving cars at "
            "Google in 2007, few people outside of the company took him "
            "seriously. “I can tell you very senior CEOs of major American "
            "car companies would shake my hand and turn away because I wasn’t "
            "worth talking to,” said Thrun, in an interview with Recode earlier "
            "this week.")
    doc = nlp(text)

    # Analyze syntax
    print("Noun phrases:", [chunk.text for chunk in doc.noun_chunks])
    print("Verbs:", [token.lemma_ for token in doc if token.pos_ == "VERB"])

    # Find named entities, phrases and concepts
    for entity in doc.ents:
        print(entity.text, entity.label_)

spacy.load() 함수를 사용해서 core를 로드합니다.

text에 일반 문장으로 입력합니다.

nlp를 사용해서 토큰화를 진행합니다.

출력 결과 일반 문장을 토큰화 하여 출력합니다.

token.pos_를 사용하면 단어를 분류하여

품사 태깅을 확인할 수 있습니다.

혹 spacy를 사용 중 오류가 발생하면 아래 내용을 참고해주세요.

https://believecom.tistory.com/746

 

python spacy 모델 사용 중 Can't find model 'en_core_web_sm'. It doesn't seem to be a Python package 오류 처리 하기

python 자연어 처리를 공부하면서 spacy모델을 사용한 기본 테스트를 하게 되면 오류가 발생합니다. 오류 내용은 "Can't find model 'en_core_web_sm'. It doesn't seem to be a Python package" 입니다. 모델이..

believecom.tistory.com

 

두 번째 오픈 NLP 패키지 nltk

https://www.nltk.org/

 

Natural Language Toolkit — NLTK 3.6.2 documentation

Natural Language Toolkit NLTK is a leading platform for building Python programs to work with human language data. It provides easy-to-use interfaces to over 50 corpora and lexical resources such as WordNet, along with a suite of text processing libraries

www.nltk.org

nltk 패키지도 import를 사용해서 설치가 가능합니다.

nltk는 패키지 다운로드 후 컴파일을 진행하면

추가 패키지를 다운로드해야 합니다.

nltk.download() 함수를 사용해서 오류 발생 시

패키지를 하나씩 선택하면 됩니다.

def nltkex():
    nltk.download('punkt')
    nltk.download('averaged_perceptron_tagger')
    nltk.download('maxent_ne_chunker')
    nltk.download('words')
    nltk.download('treebank')
    sentence = """At eight o'clock on Thursday morning Arthur didn't feel very good."""
    tokens =nltk.word_tokenize(sentence)
    print(tokens)
    tagged = nltk.pos_tag(tokens)
    print(tagged[0:6])

    eltities = nltk.chunk.ne_chunk(tagged)
    print(eltities)

    t = treebank.parsed_sents('wsj_0001.mrg')[0]
    t.draw()

nltk.word_tokenize() 함수를 사용해서 토큰화를 진행합니다.

nltk.pos_tag()함수는 품사 태깅을 진행 후 

토큰 정보를 출력할 수 있습니다.

간단한 함수 사용으로 토큰화를 진행할 수 있습니다.

청크 나구기를 하기 위해서는 nltk.chunk.ne_chunk() 함수를 사용합니다.

간단한 출력으로 문장의 청크를 구분할 수 있습니다.

파이토치(PyTorch) 자연어 처리에서 토큰, 청크 단위로 문장을

구분하면 정확한 구조를 확인하기 위해서 트리구조가 가장 좋습니다.

nltk 패키지에서는 treebank를 사용해서 트리구조

내용을 확인할 수 있습니다.

자연어 처리에서 문장을 처리하기 위한

토큰화는 가장 기본되는 작업입니다.

두 가지 오픈 패키지를 사용해서 우선적인 자연어 처리

기본을 공부하면 좋겠습니다.

감사합니다.

 

반응형
반응형

python 자연어 처리를 공부하면서 spacy모델을

사용한 기본 테스트를 하게 되면 오류가 발생합니다.

오류 내용은 "Can't find model 'en_core_web_sm'.

It doesn't seem to be a Python package" 입니다.

모델이 'en'이 포함되어 있지 않은 것으로 확인됩니다.

오류를 해결하기 위해서 검색해보니까

추가 설치가 필요하다고 합니다.

"python -m spacy download en"

cmd를 실행해서 en 모델을 추가 설치하면

정상적으로 컴파일됩니다.

커멘드 실행 후 spacy 모델에서 추가 내용을 다운로드합니다.

컴파일하면 정상적으로 token 생성이 가능합니다.

반응형
반응형

파이썬(python)은 다수 스크립트 파일을 생성해서

프로젝트를 구성할 수 있습니다.

각 스크립트는 main을 추가할 수 있으면

함수 및 모든 데이터 정보를 저장할 수 있습니다.

오늘은 파이썬(python) 메인 스크립트에서

다른 스크립트를 호출하는 방법을 알아보겠습니다.

파이썬(python)에서는 스크립트 파일을

3가지 형태로 호출할 수 있습니다.

첫 번째 import 사용

import 함수는 패키지를 포함시키는 함수이지만

스크립트 파일도 포함시킬 수 있습니다.

item.py 신규 파일을 만들어서 2개의 함수를 정의합니다.

import 함수에 선택 파일 이름을 설정합니다.

,py 확장자는 빼주세요.

정상적으로 임포트 되었다면 파일명을 입력하면

스크립트에 저장된 함수를 확인할 수 있습니다.

컴파일하면 main 함수 및 item 스크립트 함수

정보가 출력됩니다.

 

두 번째 exec 사용

두 번째는 exec 함수를 사용해서

스크립트 파일을 직접 접근할 수 있습니다.

직접 함수를 사용하지 않고 메임 함수를 호출하는 구조로

import 함수 사용과는 조금 다릅니다.

새로운 스트립트 파일을 생성 후 main을

포함해서 함수를 작성해주세요.

버전이 낮은 파이썬(python)2 버전은

execfile() 함수를 사용하면 됩니다.

exec(open("item2.py").read())

exex를 사용하면 스크립트를 확인하고

main 함수를 바로 호출합니다.

 

세 번째 subprocess 사용

subprocess 모듈을 사용하면 새 프로세스를

생성하거나 출력을 반환할 수 있습니다.

subprocess를 사용하기 전에 모듈을 import 해주세요

subprocess.call("item2.py", shell=True)

subprocess 모듈을 사용해서 신규 스크립트 파일을

실행 후 main 실행 반환 값을 확인할 수 있습니다.

subprocess, exec 사용은 스크립트를

메인을 확인하는 구조이기 때문에

유틸리티 형태를 사용하고 싶다면

import를 사용해서 직접 접근하는 방식이

가장 좋은 방법입니다.

파이썬(python)을 공부하게 되면 정말 많은

유틸리티를 만날 수 있기 때문에

필요하다면 별도 저장 후 프로그램 

개발에 적극 활용해주세요.

감사합니다.

 

반응형
반응형

블록체인(Blockchain)은 거래 기록이 담긴 블록이

체인처럼 서로 연결되어 있는 구조를  말합니다.

요즘 많은 사람들이 암호화폐에 대해서 관심 있어서

블록체인(Blockchain)은 더욱더 인기가 높아지고 있습니다.

 

오늘은 파이썬(python)을 사용해서 간단한 

블록체인(Blockchain)을 만들어보겠습니다.

먼저 블록체인(Blockchain) 특징을 알아보겠습니다.

블록체인은 3가지 특징이 있습니다.

첫 번째 특징 분산화

블록체인에 저장된 모든 정보가 전체
네트워크의 한 단위로 동작합니다.
중앙 집중식 권한이 없이 모든 노드 간의
정보 공유가 가능합니다.

두 번째 특징 불변성
블록체인의 모든 데이터는 추가 적용됩니다.
데이터를 삭제하지 않으며
과거에 무언가를 수정하려면
새로운 주석 데이터를 추가해야 합니다.

세 번째 특징 분산 원장
블록체인은 공개 또는 비공개가 가능합니다.
하지만 특정 누구에게 속하는 것이
아닌 그룹에만 속합니다.

블록체인(Blockchain)은 기본적으로 Hash를 사용해서

고유성을 유지합니다.

각 블록에는 Previous hash, Current hash를 사용해서

블록 간에 연결을 유지합니다.

파이썬(python)에서 hash를 사용하기 위해서는

hashlib를 import 해줘야 합니다.

hash를 사용할 경우 가장 중요한 내용이 있습니다.

일반적으로 hahs class를 사용해서 update를

할 경우 아래와 같은 error가 발생합니다.

"unicode-objects must be encoded before hashing"

상기 오류는 hash에 사용되는 text 정보를

encode 해줘야 합니다.

먼저 Block Class를 만들어 보겠습니다.

Block Class는 __init__ 함수를 사용해서 index, timestamp

data, previous_hash, hash를 설정합니다.

hash_block() 함수는 블록 정보를 한 번에 출력할 수 있습니다.

hash_block() 함수에서 sha.update를 사용할 경우

입력 text를 encode('utf-8') 함수를 사용해서

encode을 진행해야 오류가 발생하지 않습니다.

create_gensis_block() 함수를 생성합니다.

create_gensis_block() 함수는 초기화 함수로

최초 block을 생성합니다.

블록체인(Blockchain)을 연결하기 위한

next_block() 함수를 정의합니다.

신규 블록을 생성해서 hash 정보에

마지막 블록 hash 정보를 저장합니다.

블록체인(Blockchain)을 생성하기 위해서

최초 블록을 저장합니다.

저장된 블록은 총 20개로 순차적으로

블록을 생성해서 연결합니다.

컴파일 결과 20개의 블록이 순차적으로

연결되어 저장되었습니다.

Hash 정보를 확인하면 중복되지 않는 정보로

고유성을 유지하면서 블록체인(Blockchain)을 연결합니다.

전체 소스 내용

import datetime
import hashlib
from datetime import datetime


class Block:
    def __init__(self, index, timestamp, data, previous_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.hash = self.hash_block()
    def hash_block(self):
        sha = hashlib.sha256()
        data = str(self.index) + str(self.timestamp) +  str(self.data) + str(self.previous_hash)
        sha.update(data)
       #sha.update( data.encode('utf-8'))
        return sha.hexdigest()

def create_genesis_block():
    return Block(0, datetime.now(), "Genesis Block", "0")


def next_block(last_block):
    this_index = last_block.index + 1
    this_timestamp = datetime.now()
    this_data = "Block Data :  " + str(this_index)
    this_hash = last_block.hash
    return Block(this_index, this_timestamp, this_data, this_hash)
    
if __name__ == '__main__':
	blockchain = [create_genesis_block()]
    previous_block = blockchain[0]

    num_of_blocks_to_add = 20

    for i in range(0, num_of_blocks_to_add):
        block_to_add = next_block(previous_block)
        blockchain.append(block_to_add)
        previous_block = block_to_add
        print("Block #{} added blockchain".format(block_to_add.index))
        print("Block Data: {}n".format(block_to_add.data))
        print("Block Hash: {}n".format(block_to_add.hash))

 

블록체인(Blockchain)은 매우 복잡한 구조로 동작합니다.

오늘은 간단하게 hash를 사용해서 블록체인(Blockchain) 

개념을 확인했습니다.

파이썬(python)으로 간단하게 구현이 가능하기 때문에

한번 정도 코딩하시면서 공부하는 것을 추천합니다.

감사합니다.

반응형
반응형

파이썬(python)은 복잡한 코드도 간단하게 코딩할 수 있는 정말 좋은 프로그램 언어입니다.

파이썬을 사용하면 인터 프린터 형태로 컴파일되기 때문에 한 개의 변수 형태로 많이 사용합니다.

간단한 코드는 다양한 변수를 사용해소 코드가 가능하지만, 조금씩 변수가 증가하면 매우 복잡해지겠죠.

먼저 간단하게 이름, 주소, 전화 번호를 출력하는 프로그램을 작성해보겠습니다.

def printInfo():
    name = "365talk"
    address = "seoul"
    phone = "010-1234-5678"

    print(f"name : {name}")
    print(f"address : {address}")
    print(f"phone : {phone} ")

name, address, phone 변수를 선언 후 정보를 저장합니다.

print() 함수를 사용해서 변수를 출력합니다.

name, address, phone 모든 내용을 한 번에 확인할 수 있습니다.

그럼 이번에는 변수 한개를 더 추가해보겠습니다.

email 변수를 사용해서 mail 정보를 입력합니다.

def printInfo():
    name = "365talk"
    address = "seoul"
    phone = "010-1234-5678"
    email = "365talk@gmail.com"

    print(f"name : {name}")
    print(f"address : {address}")
    print(f"phone : {phone} ")
    print(f"email : {email}")

email 변수 추가와 동시에 출력하기 위한 print() 정보도 추가합니다.

출력 결과도 동일하게 print()함수를 사용해서 출력할 수 있습니다.

간단한 변수를 여러개 사용할 경우 추가적으로 변수를 선언하면 됩니다.

하지만 변수 개수가 증가할수록 코드 길이가 길어지면서 관리하기가 점점 힘들어집니다.

변수를 혹 배열로 사용할 경우는 변수 관리는 더욱더 복잡해집니다.

 

클래스 구조

파이썬(python)은 이러한 관리 문제를 해결하기 위해서 클래스(Class)를 사용할 수 있습니다.

클래스(Class)는 간단하게 말하면 변수 그룹, 함수 그룹을 모두 하나의 그룹으로 관리할 수 있는 집합 객체입니다.

클래스(Class)를 사용하면 객체를 복사할 수 있기 때문에 배열에 사용하기도 매우 편리합니다.

파이썬(python)에서는 함수와 동일하게 class를 단어를 앞쪽에 선언해서 클래스(Class)를 선언할 수 있습니다.

class DataInfo:
    pass


info = DataInfo()
print(info)
print(type(info))

class DataInfo 객체를 생성했습니다.

DataInfo 객체를 생성하고 출력하면 객체가 생성된 주소 정보를 확인할 수 있습니다.

DataInfo 객체 시작 주소 정보는 0x00001FDA308F7C0 입니다.

DataInfo 클래스에 추가되는 함수, 변수 모두 주소 이후 연속으로 메모리에 할당됩니다.

type() 함수를 사용하면 생성한 클래스(Class) 타입도 확인이 가능합니다.

 

클래스 만들기

처음에 코딩한 변수 출력 부분을 클래스(Class)로 변경해보겠습니다.

class DataInfo:
    def set_DataInfo(self, name, address, phone, email):
        self.name = name
        self.address = address
        self.phone = phone
        self.email = email
    def print(self):
        print(f"print -----------------")
        print(f"name : {self.name}")
        print(f"address : {self.address}")
        print(f"phone : {self.phone} ")
        print(f"email : {self.email}")
        print(f"print END--------------")

파이썬(python)에서 클래스(Class)를 사용하기 위해서는 메서드앞에 self를 반드시 추가해야 합니다.

self는 클래스(Class)에 생성되는 모든 메서드에 포함되어야 합니다.

set_DataInfo() 메서드 사용 시 self에 name, address, phone, email 변수를 선언하고 인자를 저장합니다.

self에 저장된 변수는 print() 함수를 이용해서 각 변수에 접근 후 출력이 가능합니다.

name = "365talk"
address = "seoul"
phone = "010-1234-5678"
email = "365talk@gmail.com"

info = DataInfo()
info.set_DataInfo(name, address, phone, email)
info.print()

info 변수에 DataInfo() 클래스를 할당합니다.

set_DataInfo() 메서드를 사용해서 name, address, phone, email 정보를 저장할 수 있습니다.

클래스(Class) 객체 선언 후 간단하게 print() 메소드를 사용해서 모든 정보를 출력할 수 있습니다.

파이썬(phthon)에서 클래스(Class)를 사용하게 되면 모든 메서드에 self 인자를 무조건 처음에 사용해야 합니다.

self를 사용하지 않으면 컴파일 과정에서 오류가 발생합니다.

파이썬(phthon)에 사용되는 self 인자는 클래스(Class) 내부 인스턴스 객체로 초기 설정값을 저장하고 인스턴스 형태로 접근이 가능합니다.

즉 인스턴스 형태 메서드를 사용하던, 클래스 형태 메서드를 사용하던 모두 하나의 주소 정보에 접근합니다.

조금 어려운 부분이지만, 그냥 간단하게 객체를 관리하는 집주인이라고 생각하시면 됩니다.

 

클래스 초기화 __init__ 메서드

파이썬(phthon) 클래스(Class)에서도 생성자를 사용한 초기화가 가능합니다.

class DataInfo:
    def __init__(self, id):
        self.id = id
        print("Class Init")
    def set_DataInfo(self, name, address, phone, email):
        self.name = name
        self.address = address
        self.phone = phone
        self.email = email
    def print(self):
        print(f"print -----------------")
        print(f"name : {self.name}")
        print(f"address : {self.address}")
        print(f"phone : {self.phone} ")
        print(f"email : {self.email}")
        print(f"id : {self.id}")
        print(f"print END--------------")

생성된 클래스(Class)에서 __init___ 메서드를 사용해서 초기화가 가능합니다.

__init__ 메서드는 객체가 처음 생성되는 시점에 무조건 호출됩니다.

DataInfo 객체를 선언하는 시점에 __init__에 코딩한 print() 함수가 호출되는 것을 확인할 수 있습니다.

파이썬(python) 클래스(Class)에 미리 선언된 메서드는 "__이름__" 형태로 선언되어 있습니다.

파이참을 사용할 경우 메서드를 바로 확인할 수 있기 때문에 다양한 메서드를 확인해보세요.

파이썬(python) 클래스(Class)는 다양한 API 객체로 배포되기 때문에 꼭 알아야 하는 개념입니다.

클래스(Class) 사용 개념이 없을 경우 크롤링, 주식 API 등 복잡한 코드에 접근하기 어렵습니다.

오늘도 열심히 파이썬(Python) 공부하세요.

감사합니다.

 

반응형
반응형

파이썬(python)에서 사용할 수 있는 팁 러닝 라이브러리 파이토치(PyTorch)는 팁 러닝에서 가장 많이 사용되는

신경망(Neural Networks)을 간편하게 변형하면서 활용이 가능합니다.

신경망(Nural Networks)은 피드 포인트 네트워크가 여러개의 레이어를 차례로 통과시킨 다음 마지막으로 출력을 반환하는 기술입니다.

학습 가능한 파라미터 및 가중치를 적용하여 입력 데이터 세트를 반복하면서 손실 계산 후 보정을 거쳐 네트워크의 가중치를 업데이트합니다.

파이토치(PyTorch)는 신경망(Nural Networks) 데이터에 대한 작업을 수행할 수 있는 계층, 모델을 지원합니다.

torch.nn 네임스페이스를 사용해서 신경 네트워크를 구축에 필요한 빌링 블록을 제공합니다.

신경망(Nural Networks)은 CPU 활용보다는 GPU 모델로 사용하는 것을 권장합니다.

GPU를 사용하기 위해서 Torch.cuda 설치 여부를 확인합니다.

evice = 'cuda' if torch.cuda.is_available() else 'cpu'
    print('Using {} device'.format(device))

전 아직 cuda 설치 전이기 때문에 cpu만 사용이 가능합니다.

 

신경망(Nural Nwtworks)를 사용하기 위해서 서브 클래싱을 통한 nn.Module 계층을 초기화가 필요합니다.

def CheckDevice():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print('Using {} device'.format(device))

    model = NeuralNetwork().to(device)
    print(model)

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

nn.Module 하위 클래스는 forward 메서드의 입력 데이터에 대한 작업을 구현했습니다.

클래스를 사용한 인스턴스를 만들고 device 정보를 출력했습니다.

__init__에 정의된 정보가 device에 저장되어 출력됩니다.

forward는 백그라운드 작업으로 진행되기 때문에 model.forward()를 직접 호출할 필요가 없습니다.

X = torch.rand(1, 28, 28, device=device)
    logits = model(X)
    pred_probab = nn.Softmax(dim=1)(logits)
    y_pred = pred_probab.argmax(1)
    print(f"Predicted class: {y_pred}")

정의된 클래스에 원시 예측 값이 있는 10차원 텐서를 설정하기 위해서, nn.Softmax 모듈의 인스턴스를 사용해서 예측 확률을 확인합니다.

 

파이 토치 신경망 모델 레이어

모델의 레이어를 구분하기 위해서 간단한 28 x 28인 이미지 3개의 샘플을 저장합니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

3개의  28 x 28 이미지를 확인할 수 있습니다.

nn.Flatten 레이어를 초기화하여 각 2D 28 x 28 이미지를 784 픽셀 값의 연속 배열로 변환합니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

    flatten = nn.Flatten()
    flat_image = flatten(input_image)
    print(flat_image.size())

3개의 배열이 784 연속 배열로 변경되었습니다.

nn.Linear은 선형 레이어를 구현할 수 있습니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

    flatten = nn.Flatten()
    flat_image = flatten(input_image)
    print(flat_image.size())

    layer1 = nn.Linear(in_features=28 * 28, out_features=20)
    hidden1 = layer1(flat_image)
    print(hidden1.size())

hidden1 선형 레이어를 생성했습니다.

nn.ReLU은 입력과 출력 사이에 복잡한 매핑 비선형성을 사용할 수 있습니다.

선형 레이어 사이에 nn.ReLU를 사용해서 비선형성을 실행합니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

    flatten = nn.Flatten()
    flat_image = flatten(input_image)
    print(flat_image.size())

    layer1 = nn.Linear(in_features=28 * 28, out_features=20)
    hidden1 = layer1(flat_image)
    print(hidden1.size())

    print(f"Before ReLU: {hidden1}\n\n")
    hidden1 = nn.ReLU()(hidden1)
    print(f"After ReLU: {hidden1}")

nn.Sequential은 모듈의 순서가 지정된 컨테이너를 생성할 수 있습니다.

정의된 데이터와 동일한 순서로 모든 모듈에 전달됩니다.

순차 컨테이너는 빠른 네트워크를 구성하기 위해서 사용됩니다.

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
    )
    input_image = torch.rand(3,28,28)
    logits = seq_modules(input_image)
    print(logits)

nn.Softmax는 원시 값인 로짓을 반환합니다.

로짓은 각 클래스에 대한 모델의 확률을 나타내는 값[0,1]으로 지정됩니다.

매개변수는 값의 합이 1이 되어야 차원을 나타냅니다.

    softmax = nn.Softmax(dim=1)
    pred_probab = softmax(logits)

    print(pred_probab)

 

파이 토치 신경망 모데 매개변수

신경망에 사용되는 레이어는 매개변수화되어 있어 접근이 가능합니다.

서브 클래싱 된 nn.Module은 객체 내부에 정의된 모든 필드를 자동으로 추적하고 모델 parameters() 또는 named_parameters() 메서드를 사용하여 모든 매개변수에 액세스 할 수 있습니다.

    print("Model structure: ", model, "\n\n")

    for name, param in model.named_parameters():
        print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

처음 구현한 model에 추가 코드를 적용해서 매개변수를 확인했습니다.

파이토치(PyTorch) 신경망(Nural Networks)은 복잡한 정보를 클래스를 사용해서 다양한 구성이 가능합니다.

모델 레이어를 사용해서 가중치를 높이면서 정확한 데이터를 확보할 수 있습니다.

감사합니다.

반응형
반응형

파이썬(python)에서 사용할 수 있는 파이토치(PyTorch)는 간단하게 딥 러닝을 구현할 수 있는 좋은 라이브러리입니다.

오늘은 파이토치(PyTorch)에서 딥 러닝에서 많이 사용되는 데이터 정보를 관리할 수 있는 데이터 세트(Dataset) 및 데이터 로더(Dataloader)에 대해서 알아보겠습니다.

배열과 같은 데이터 정보는 단순한 형태를 사용하기 편리하지만, 정보가 증가하면 유지 관리하기 어렵습니다.

데이터 세트(Dataset)는 가독성을 높이면서 데이터를 쉽게 액세스 할 수 있도록 도와줍니다.

파이토치(PyTorch) 데이터 세트(Dataset)를 사용하기 위해서는 torchvision 패키지를 인스톨해야 합니다.

torchvision 패키지 인스톨을 진행하면 java SDK를 업데이트합니다.

설치 화면에서 설치를 클릭해주세요.

 

데이터 세트(Dataset)는 기본적으로 사용할 수 있는 데이터 정보를 다운로드하여 저장할 수 있습니다.

training_data = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor()
    )

FashionMNIST 메서드를 사용해서 이미지 정보를 training_data에 저장합니다.

FashionMNIST 메서드 root는 테스트 데이터 저장 경로입니다.

train은 데이터 세트 지정 정보입니다.

download는 데이터 다운로드 설정 정보입니다.

transform은 레이블 변환 지정입니다.

코드를 실행하면 출력 창에서 이미지 다운로드 화면을 확인할 수 있습니다.

training_data에 저장된 데이터 세트(Dataset) 정보를 출력해보겠습니다.

def showimage():
    training_data = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor()
    )
    labels_map = {
        0: "T-Shirt",
        1: "Trouser",
        2: "Pullover",
        3: "Dress",
        4: "Coat",
        5: "Sandal",
        6: "Shirt",
        7: "Sneaker",
        8: "Bag",
        9: "Ankle Boot",
    }
    figure = plt.figure(figsize=(8, 8))
    cols, rows = 3, 3
    for i in range(1, cols * rows + 1):
        sample_idx = torch.randint(len(training_data), size=(1,)).item()
        img, label = training_data[sample_idx]
        figure.add_subplot(rows, cols, i)
        plt.title(labels_map[label])
        plt.axis("off")
        plt.imshow(img.squeeze(), cmap="gray")
    plt.show()

배열에 저장된 9개의 이미지 정보를 기준으로 데이터 세트(Dataset)에서 이미지를 확인 후 matplotlib 패키지 plt를 사용해서 이미지로 출력합니다.

출력 결과 9개의 이미지가 순차적으로 출력됩니다.

데이터 세트(Dataset)는 예제 정보를 다운로드할 수 있어 간단하게 이미지 관련 딥러닝을 실행할 수 있습니다.

 

데이터 세트(Dataset)는 배열처럼 사용하는 방법보다는 클래스로 구현하면 더욱더 쉽게 사용할 수 있습니다.

기복적으로 __init__, __len__, __getitem__ 세 가지를 함수를 추가 구현할 수 있습니다.

class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        self.img_labels = pd.read_csv(annotations_file)
        self.img_dir = img_dir
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        return len(self.img_labels)

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        image = read_image(img_path)
        label = self.img_labels.iloc[idx, 1]
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            label = self.target_transform(label)
        return image, label

클래스에 사용할 수 있는 기본 함수는 자동 생성되기 때문에 필요한 부분을 추가 구현할 수 있습니다.

__init__ 함수는 데이터 세트(Dataset) 객체를 인스턴스화 할 때 한번 실행됩니다.

기본적으로 초기화에 필요한 정보를 입력할 수 있습니다.

__len__ 함수는 데이터 세트(Dataset) 객체 개수를 반환합니다.

__getitem__ 함수는 선택한 인덱스의 데이터 정보를 로드하여 반환합니다.

변환 정보는 처음 배운 텐서로 변환되어 사용할 수 있습니다.

 

데이터 로더(Dataloader)는 데이터 세트 클래스의 확장 형태로 간단하게 데이터 세트를 접근할 수 있습니다.

간단하게 말해서 데이터 로더(Dataloader)는 데이터 세트의 복잡성을 간단한 API로 추상화한 클래스입니다.

데이터 로더(Dataloader)를 사용하기 위해서 torch.utils.data 패키지를 설치합니다.

def DataLoaderEx():
    training_data = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor()
    )
    train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)

    train_features, train_labels = next(iter(train_dataloader))
    print(f"Feature batch shape: {train_features.size()}")
    print(f"Labels batch shape: {train_labels.size()}")
    img = train_features[1].squeeze()
    label = train_labels[1]
    plt.imshow(img, cmap="gray")
    plt.show()
    print(f"Label: {label}")

데이터 로더(Dataloader)를 로드된 데이터 세트를 생성자에 대입만 하면 바로 사용이 가능합니다.

데이터 로더(Dataloader)는 배열 사용과 동일하게 인덱스를 입력하면 바로 이미지를 확인할 수 있습니다.

데이터 로더(Dataloader) 인덱스 정보를 변경하면 다음 이미지를 확인할 수 있습니다.

파이토치(PyTorch)  데이터 세트(Dataset) 및 데이터 로더(Dataloader)는 이미지 정보와 같은 복잡한 정보를 누구가 쉽게 사용할 수 있도록 구현된 객체입니다.

기본 정보를 다운로드하여 객체에 저장하기 때문에 별도 이미지를 찾을 필요가 없습니다.

딥 러닝은 코드 보다도 알고리즘이 중요하기 때문에 코드를 매우 단순화할 수 있는 좋은 패키지라고 생각됩니다.

감사합니다.

https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html

 

Quickstart — PyTorch Tutorials 1.9.0+cu102 documentation

Note Click here to download the full example code Learn the Basics || Quickstart || Tensors || Datasets & DataLoaders || Transforms || Build Model || Autograd || Optimization || Save & Load Model Quickstart This section runs through the API for common task

pytorch.org

 

반응형
반응형

오늘은 파이토치(PyYorch)에서 가장 기본으로 사용되는 텐서(Tensor)에 대해서 알아보겠습니다.

텐서(Tensor)는 배열 및 행렬과 매우 유사한 특수 데이터 구조입니다

행렬을 배열처럼 사용할 수 있어서 복잡한 행렬 계산을 빠르게 진행할 수 있습니다.

텐서(Tensor)는 GPU또는 기타 하드웨어 가속기에서 실행할 수 있는 점을 제외하고는 NumPy의 ndarray와 유사합니다.

또한 텐서(Tensor)는 자동 미분에 최적화되어 있습니다.

먼저 텐서(Tensor)에 초기화에 대해서 알아보겠습니다.

def tensorEx1():
    data = [[1,2],[3,4]]
    x_data = torch.tensor(data)

    x_ones = torch.ones_like(x_data)
    print(f"Ones Tensor: \n{x_ones} \n")
    x_rand = torch.rand_like(x_data, dtype=torch.float)
    print(f"Random Tensor: \n {x_rand} \n")

간단한 코드를 사용해서 텐서(Tensor)를 초기화 할 수 있습니다.

결과 값은 초기화된 정보가 행렬로 저장되어 있습니다.

텐서(Tensor)는 명시적으로 재정의하지 않는 한 인수 텐서의 속성을 그대로 유지합니다.

텐서(Tensor)는 rand, ones, zeros를 사용해서 명시적으로 초기화가 가능합니다.

def tensorEx2():
    shape = (4,5,)
    rand_tensor = torch.rand(shape)
    ones_tensor = torch.ones(shape)
    zeros_tensor = torch.zeros(shape)

    print(f"Random Tensor: \n {rand_tensor} \n")
    print(f"Ones Tensor: \n {ones_tensor} \n")
    print(f"Zeros Tensor: \n {zeros_tensor} \n")

    print(f"Shape of Tensor : { rand_tensor.shape}")
    print(f"Datatype of Tensor : { rand_tensor.dtype}")
    print(f"Device Tensor is stored on : { rand_tensor.device}")

shape는 텐서(Tensor) 차원의 듀플입니다.

rand를 사용하면 랜덤 한 설정으로 초기화됩니다.

ones는 모두 1로 초기화되며, zeros는 모두 0으로 초기화됩니다.

텐서(Tensor)는 속성 메서드를 사용해서 정보를 확인할 수 있습니다.

shape, dtype, device 속성 정보 확인이 가능합니다.

출력 결과 초기화된 정보 및 속성 정보를 확인할 수 있습니다.

텐서(Tensor)는 산술, 선형대수, 행렬 조작, 샘플링 등을 포함한 100개 이상의 연산이 가능합니다.

모든 연산 정보는 아래 사이트를 확인해주세요.

https://pytorch.org/docs/stable/torch.html

 

torch — PyTorch 1.9.0 documentation

Shortcuts

pytorch.org

텐서(Tensor) 연산은 GPU에서 실행이 가능하여 일반적인 CPU 보다 빠른 속도 연산이 가능합니다.

기본은 CPU에서 연산이 진행되며 .to 메서드를 사용해서 GPU로 이동이 가능합니다.

간단하게 행렬에 접근하는 방법을 알아보겠습니다.

def tensorEx3():
    tensor = torch.ones(5,5)
    print('\n')
    print(tensor)
    print('First row: ', tensor[0])
    print('First column: ', tensor[:0])
    print('Last column:', tensor[...,-1])
    tensor[:,1] = 4
    print(tensor)

텐서(Tensor) 행렬에 원하는 위치 정보를 출력할 수 있거나 행에 포함된 모든 정보를 한 번에 변경이 가능합니다.

또한 처음, 마지막 접근이 가능합니다.

출력 결과 두 번째 위치 컬럼을 4로 초기화했습니다.

행렬이면서 배열과 동일하게 사용할 수 있어 정말 편리합니다.

 

텐서(Tensor)는 간단하게 행렬을 합할 수 있습니다.

 tensor = torch.ones(5,5)
 t1 = torch.cat([tensor, tensor, tensor], dim=1)
 print(f"\n{t1}\n")

cat 메서드를 사용하면 3개의 텐서(Tensor)를 합할 수 있습니다.

출력 결과 15개의 행렬을 확인할 수 있습니다.

 

텐서(Tensor)는 다양한 산술 연산이 가능합니다.

tensor1 = tensor + tensor
    print(f"\n{tensor1} \n")

    y1 = tensor @ tensor.T
    y2 = tensor.matmul(tensor.T)
    y3 = torch.rand_like(tensor)
    torch.matmul(tensor, tensor.T, out=y3)
    print(f"\n {y3} \n")

    z1 = tensor * tensor
    z2 = tensor.mul(tensor)
    z3 = torch.rand_like(tensor)
    torch.mul(tensor, tensor, out=z3)
    print(f"\n {z3} \n")

    agg = tensor.sum()
    agg_item = agg.item()
    print(agg_item, type(agg_item))

산순 연산을 사용해서 텐서(Tensor)를 다양고 쉽게 사용할 수 있습니다.

 

텐서(Tensor)는 copy를 사용해서 복사가 가능합니다.

복사를 하지 않을 경우는 동일한 객체로 인식되어 수정 시 모든 객체에 수정이 반영됩니다.

    copy = torch.ones(5,5)
    tensor.copy_(copy)
    tensor.add_(7)
    print(f"\n{copy} \n")
    print(f"\n{tensor} \n")

복사를 하게되면 복사된 정보는 새로운 객체로 인식되어 별도 수정이 가능합니다.

출력 결과 복사된 정보를 변경하면 이전 정보에 반영되지 않습니다.

 

텐서(Tensor)는 NumPy 배열로 변경이 가능합니다.

def tensorEx5():
    t = torch.ones(7)
    print(f"\n t : {t} \n")
    n = t.numpy()
    print(f"\n n: {n} \n")

    t.add_(2)
    print(f"\n t : {t} \n")
    print(f"\n n: {n} \n")

텐서(Tensor)에 변경된 내용이 NumPy 배열에 반영되는 것을 확인할 수 있습니다.

반대로 NumPy 배열을 텐서(Tensor)로 이동이 가능합니다.

def tensorEx6():
    n = np.ones(8)
    t = torch.from_numpy(n)
    np.add(n,1, out=n)
    print(f"\n t : {t} \n")
    print(f"\n n: {n} \n")

출력 결과 NumPy배열의 변경 내용이 텐서(Tensor)에 반영되었습니다.

텐서(Tensor)는 팁 러닝에 기본이 되는 배열 및 행렬과 매우 유사한 특수 데이터 구조로 빠른 계산 및 가독성이 매우 좋습니다.

일반적인 언어에서 어렵게 계산해야 하는 행렬을 단 몇 줄 코드로 계산이 가능합니다.

또한 GPU를 사용할 수 있어 복잡한 계산을 더욱더 빠르게 연산할 수 있습니다.

파이토치(PyTouch)를 사용하기 위해서는 기본 객체이기 때문에 반드시 사용법을 확인해주세요.

감사합니다.

https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html#sphx-glr-beginner-blitz-tensor-tutorial-py

 

Tensors — PyTorch Tutorials 1.9.0+cu102 documentation

Note Click here to download the full example code Tensors Tensors are a specialized data structure that are very similar to arrays and matrices. In PyTorch, we use tensors to encode the inputs and outputs of a model, as well as the model’s parameters. Te

pytorch.org

https://believecom.tistory.com/736?category=1197289 

 

[python] 파이썬 파이 토치 PyTorch 설치하기

파이토치(PyTouch)는 토치(Torch) 및 카페2(Caffe2)를 기반으로 한 텐서 플로우와 유사한 딥러닝 라이브러리입니다. 다양한 인공지능이 연구되면서 빠른 속도를 자랑하는 파이토치(PyTouch)사용 비중이

believecom.tistory.com

 

반응형
반응형

파이토치(PyTouch)는 토치(Torch) 및 카페2(Caffe2)를 기반으로 한 텐서 플로우와 유사한 딥러닝 라이브러리입니다.

다양한 인공지능이 연구되면서 빠른 속도를 자랑하는 파이토치(PyTouch)사용 비중이 높아지고 있습니다.

페이스북에서도 파이토치(PyTouch)를 2018년 3월부터 기존 딥러닝 프레임워크와 합쳐 사용 중입니다.

오늘은 GPU 연산으로 빠른 속도를 자랑하는 파이토치(PyTouch) 설치방법을 알아보겠습니다.

파이토치(PyTouch)를 설치하기 위해서는 아래 링크로 이동해주세요.

https://pytorch.org/

 

PyTorch

An open source machine learning framework that accelerates the path from research prototyping to production deployment.

pytorch.org

하단에 있는 "Install" 버튼을 클릭하면 인스톨 페이지로 이동합니다.

파이토치(PyTouch) 설치 페이지에서는 다양한 방법으로 설치가 가능합니다.

파이참 및 pip가 설치되어 있다면 간단하게 파이토치(PyTouch)를 설치할 수 있습니다.

파이토치(PyTouch) 설치 페이지 중간에 설치 환경을 선택할 수 있습니다.

환경을 선택하면 "Run this Command"에 출력된 내용을 복사해주세요.

pip 기능을 사용해서 인스톨을 진행했습니다.

설치 파일 크기는 1.4G 정도로 5분 정도 설치 시간이 소요됩니다.

파이토치(PyTouch)가 정상적으로 설치되었습니다.

파이참을 사용하면 패키지를 선언하고 마우스를 클릭해서 설치가 가능합니다.

파이토치(PyTouch) 설치를 실행하면 하단에 설치 진행 메시지를 확인할 수 있습니다.

파이토치(PyTouch)는 간단하면서도 빠르게 딥러닝을 공부할 수 있는 좋은 라이브러리입니다.

간단하게 설치할 수 있으니까 한번 도전해보세요.

감사합니다.

반응형
반응형

오늘은 지난 시간에 배운 matplotlib를 활용해서 여러 개의 파이썬 그래프를 그려보겠습니다.

파이썬 그래프는 다양한 타입이 있지만 오늘은 가장 많이 사용하는 막대그래프, 수평 막대그래프,

산점도 그래프, 히스토리 그래프, 차트 그래프를 알아보겠습니다.

첫 번째 파이썬 그래프는 막대그래프입니다.

matplotlib에서 bar() 함수를 사용해서 막대그래프를 확인할 수 있습니다.

def bar():
    xpos = np.arange(4)
    years = ["2018", "2019", "2020", "2021"]
    values = [200,300,400,500]

    plt.bar(xpos, values, align='edge', color='red')
    plt.xticks(xpos, years)
    plt.xlabel("years")
    plt.ylabel("trading volume")
    plt.show()

bar() 함수를 선언해서 파이썬 막대 그래프 코드를 입력하겠습니다.

xpos 배열을 사용해서 x축 정보를 저장합니다.

x축, y축 개수가 다를 경우 오류가 발생합니다. 정확한 개수를 확인해주세요.values 배열을 사용해서 y축 정보를 저장합니다.bar() 함수에, x, y 축 정보를 입력하고 기본 옵션을 지정합니다.

출력 결과 RED 색상 파이썬 막대그래프를 확인할 수 있습니다.

일반적으로 많이 사용되는 내용이기 때문에 그래프가 어떻게 구성되는지 감을 잡아주시면 됩니다.

 

두 번째는 파이썬 수평 막대 그래프를 알아보겠습니다.

matplotlib 패키지에서 barh함수를 사용해서 출력할 수 있습니다.

def barh():
    ypos = np.arange(4)
    years = ["2018", "2019", "2020", "2021"]
    values = [200, 300, 400, 500]
    plt.barh(ypos, values, tick_label=years)
    plt.ylabel("trading volume")
    plt.show()

barh 함수는 y축을 기준으로 정보가 동일해야 합니다.

tick_label 파라미터를 사용해서 y축 타이틀을 설정할 수 있습니다.

4개의 파이썬 수평 막대 그래프를 확인할 수 있습니다.

 

세 번째는 파이썬 산점도 그래프를 알아보겠습니다.

산점도 그래프는 x, y축 좌표에 데이터를 점으로 출력하는 그래프입니다.

분포도 사용 시 많이 사용되는 그래프입니다.

matplotlib 패키지에서 scatter() 함수를 사용해서 그래프를 그릴 수 있습니다.

def scatter():
    np.random.seed(19488045)

    N = 70
    xpos = np.random.rand(N)
    ypos = np.random.rand(N)
    colors = np.random.rand(N)
    area = ( 30 * np.random.rand(N))**2

    plt.scatter(xpos,ypos, s=area, c=colors, alpha=0.5)
    plt.show()

seed를 사용해서 랜덤 함수를 생성합니다.

seed() 함수는 0 ~ 4294967295 사이의 정수를 사용합니다.

random() 함수를 사용해서 설정된 값에 오차 범위를 지정합니다.

x , y 좌표에 70개의 난수 그래프가 출력됩니다.

투명도를 0.5로 지정해서 겹치는 부분까지 확인이 가능합니다.

 

네 번째는 파이썬 히스토리 그래프를 알아보겠습니다.

히스토리 그래프는 많은 데이터를 한눈에 보기에 좋은 그래프입니다.

구간별로 겹치지 않아 주식과 같은 차트 정보에 많이 사용되는 그래프입니다.

matplotlib에서 hist() 함수를 사용하면 히스토리 그래프를 사용할 수 있습니다.

def hist():
    apos = 2.0 * np.random.rand(10000) - 1.0
    bpos = np.random.standard_normal(10000)
    cpos = 20.0 * np.random.rand(5000) - 10.0
    dpos = 20.0 * np.random.rand(2000) - 10.0

    plt.hist(apos, bins=100, density=True, alpha=0.7, histtype='step')
    plt.hist(bpos, bins=50, density=True, alpha=0.5, histtype='stepfilled')
    plt.hist(cpos, bins=100, density=True, alpha=0.9, histtype='step')
    plt.hist(dpos, bins=50, density=True, alpha=0.5, histtype='stepfilled')
    plt.show()

파이썬 히스토리 그래프는 random() 함수를 사용해서 다양한 정보를 저장할 경우 균일한 편차를 주어야 여러 개의 그래프를 비교할 수 있습니다.

편차가 다를 경우 그래프가 이동하기 때문에 전체 그래프가 작아집니다.

histtype에서 step은 막대 내부가 비어 있는 상태입니다,

stepfilled는 막대 내부가 채워진 상태입니다.

출력 결과 4개의 그래프가 다양한 형태로 출력되는 것을 확인할 수 있습니다.

 

마지막으로 파이썬 차트 그래프를 알아보겠습니다.

차트 그래프는 matplotlib에서 pie() 함수를 사용해서 출력할 수 있습니다.

def pie():
    pos = [24, 56,12,34]
    labels = ['pos1', 'pos2', 'pos3', 'pos4']

    plt.pie(pos,labels=labels, autopct='%.1f%%', startangle=260, counterclock=False, shadow=True)

    plt.show()

pos를 사용해서 전체 개수를 지정하고, labels로 타이틀을 설정할 수 있습니다.

autopct 파라미터를 사용해서 내부 출력 타입을 지정할 수 있습니다.

차트 그래프는 부채꼴의 중심각 비율에 비례하게 출력됩니다.

shadow 파리 미터를 사용해서 외각 그림자를 사용할 수 있습니다. 

 파이썬 차트 그래프는 전체 분포도를 확인할 수 있는 편리한 그래프입니다.

파이썬은 다양한 크롤링을 사용해서 그래프를 사용하는 코드가 많습니다.

간단한 함수를 사용해서  파이썬 그래프를 사용할 수 있어 초보자도 쉽게 차트 분석이 가능합니다.

위 5개의 그래프만 잘 사용해도 크롤링한 정보를 출력하기에는 부족함이 없어 보입니다.

감사합니다.

#파이썬 #그래프 #그래프타입 #python

반응형

+ Recent posts