BelieveCom

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

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

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

문장을 해석해야 합니다.

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

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

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

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

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

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

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

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

첫 번째 오픈 NLP 패키지 spacy

https://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

두 번째 오픈 NLP 패키지 nltk

https://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)에서 사용할 수 있는 팁 러닝 라이브러리 파이토치(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

오늘은 파이토치(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

텐서(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

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

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

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

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

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

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

https://pytorch.org/

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

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

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

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

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

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

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

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

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

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

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

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

감사합니다.