forked from filipg/aitech-eks-pub
Przykłady w PyTorchu
This commit is contained in:
parent
8f531a680c
commit
3d70d8a7ec
44
wyk/pytorch-regression/analyzer.py
Normal file
44
wyk/pytorch-regression/analyzer.py
Normal file
@ -0,0 +1,44 @@
|
||||
import regex as re
|
||||
from sklearn.feature_extraction.text import HashingVectorizer
|
||||
import torch
|
||||
|
||||
|
||||
token_root_len = 7
|
||||
|
||||
|
||||
class Analyzer(object):
|
||||
|
||||
def __init__(self):
|
||||
self.token_pat = re.compile(r'(?:\p{L}|\d)+')
|
||||
|
||||
def __call__(self, doc):
|
||||
return [tok[0:token_root_len] for tok in self.token_pat.findall(doc)]
|
||||
|
||||
|
||||
# hiperparametr - liczba bitów hasza
|
||||
vector_length = 2**18
|
||||
|
||||
|
||||
vectorizer = HashingVectorizer(n_features=vector_length, analyzer=Analyzer())
|
||||
|
||||
midpoint = 1913.0
|
||||
|
||||
|
||||
def vectorize_text(content):
|
||||
# musimy przekonwertować macierz sklearn => macierz numpy => tensor pytorcha
|
||||
return (torch.from_numpy(vectorizer.fit_transform([content]).toarray()))[0]
|
||||
|
||||
|
||||
def vectorize_batch(contents):
|
||||
# musimy przekonwertować macierz sklearn => macierz numpy => tensor pytorcha
|
||||
return (torch.from_numpy(vectorizer.fit_transform(contents).toarray()))
|
||||
|
||||
|
||||
|
||||
def process_line(line):
|
||||
fields = line.strip('\n').split('\t')
|
||||
|
||||
year_from, year_to, _, _, content = fields
|
||||
# normalizujemy lata do wartości (-1,1)
|
||||
year_normalized = ((float(year_from) + float(year_to)) / 2 - midpoint) / 100.0
|
||||
return (content, torch.tensor(year_normalized))
|
41
wyk/pytorch-regression/analyzer_classification.py
Normal file
41
wyk/pytorch-regression/analyzer_classification.py
Normal file
@ -0,0 +1,41 @@
|
||||
import regex as re
|
||||
from sklearn.feature_extraction.text import HashingVectorizer
|
||||
import torch
|
||||
|
||||
|
||||
token_root_len = 7
|
||||
|
||||
|
||||
class Analyzer(object):
|
||||
|
||||
def __init__(self):
|
||||
self.token_pat = re.compile(r'(?:\p{L}|\d)+')
|
||||
|
||||
def __call__(self, doc):
|
||||
return [tok[0:token_root_len] for tok in self.token_pat.findall(doc)]
|
||||
|
||||
|
||||
# hiperparametr - liczba bitów hasza
|
||||
vector_length = 2**18
|
||||
|
||||
|
||||
vectorizer = HashingVectorizer(n_features=vector_length, analyzer=Analyzer())
|
||||
|
||||
def vectorize_text(content):
|
||||
# musimy przekonwertować macierz sklearn => macierz numpy => tensor pytorcha
|
||||
return (torch.from_numpy(vectorizer.fit_transform([content]).toarray()))[0]
|
||||
|
||||
|
||||
def vectorize_batch(contents):
|
||||
# musimy przekonwertować macierz sklearn => macierz numpy => tensor pytorcha
|
||||
return (torch.from_numpy(vectorizer.fit_transform(contents).toarray()))
|
||||
|
||||
|
||||
|
||||
def process_line(line):
|
||||
fields = line.strip('\n').split('\t')
|
||||
|
||||
label, content = fields
|
||||
# normalizujemy lata do wartości (-1,1)
|
||||
y = float(label)
|
||||
return (content, torch.tensor(y))
|
24
wyk/pytorch-regression/linear0-infer.py
Executable file
24
wyk/pytorch-regression/linear0-infer.py
Executable file
@ -0,0 +1,24 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import sys
|
||||
|
||||
from analyzer import midpoint, vectorize_text
|
||||
import torch
|
||||
|
||||
w = torch.load('model.bin')
|
||||
|
||||
|
||||
def model(w, x):
|
||||
return x @ w
|
||||
|
||||
|
||||
for line in sys.stdin:
|
||||
line = line.strip('\n')
|
||||
content = line
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
y_hat = model(w, x)
|
||||
|
||||
# na wyjściu musimy mieć z powrotem rok
|
||||
print(max(1814.0, min(2013.999, y_hat.item() * 100.0 + midpoint)))
|
68
wyk/pytorch-regression/linear0.py
Executable file
68
wyk/pytorch-regression/linear0.py
Executable file
@ -0,0 +1,68 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import sys
|
||||
import torch
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_text
|
||||
|
||||
# Nasz model to zestaw wag w. Na koniec dojdziemy do modeli
|
||||
# Transformer o wielu milionach wag; w pewnym sensie algorytm
|
||||
# uczenia się nie zmieni.
|
||||
# W naszym zadaniu lepiej zacząć od zerowych wag zamiast losowych.
|
||||
# Znaczenie `requires_grad` zostanie omówione w kolejnym skrypcie.
|
||||
w = torch.zeros(vector_length, dtype=torch.double, requires_grad=False)
|
||||
|
||||
# Hiperparametr uczenia
|
||||
learning_rate = torch.tensor(.0032, dtype=torch.double)
|
||||
|
||||
|
||||
def model(w, x):
|
||||
# @ to iloczyn wektorów/macierzy w PyTorchu
|
||||
return x @ w
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return (y_hat - y_exp)**2
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 5000
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
for line in sys.stdin:
|
||||
content, y_exp = process_line(line)
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
# wartość z predykcji
|
||||
y_hat = model(w, x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
# Obliczamy gradient i aktualizujemy wagi.
|
||||
# TU SIĘ ODBYWA UCZENIE!
|
||||
grad = (y_hat - y_exp)
|
||||
w = w - learning_rate * x * grad
|
||||
|
||||
# (Niedogodność tej wersji: jeśli zmienimy model lub funkcję kosztu,
|
||||
# będziemy musieli zróżniczkować wszystko i ustalić formułę na grad.
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
closs += loss
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp.item(), " => ", y_hat.item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(w, "model.bin")
|
23
wyk/pytorch-regression/linear1-infer.py
Executable file
23
wyk/pytorch-regression/linear1-infer.py
Executable file
@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import sys
|
||||
|
||||
from analyzer import vectorizer
|
||||
import torch
|
||||
|
||||
w = torch.load('model.bin')
|
||||
|
||||
|
||||
def fun(w, x):
|
||||
return x @ w
|
||||
|
||||
|
||||
for line in sys.stdin:
|
||||
line = line.strip('\n')
|
||||
content = line
|
||||
|
||||
x = (torch.from_numpy(vectorizer.fit_transform([content]).toarray()))[0]
|
||||
|
||||
y_hat = fun(w, x)
|
||||
|
||||
print(max(1814.0, min(2013.999, y_hat.item() * 100.0 + 1913.0)))
|
70
wyk/pytorch-regression/linear1.py
Executable file
70
wyk/pytorch-regression/linear1.py
Executable file
@ -0,0 +1,70 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# To samo co linear0.py tylko z automatycznym różniczkowaniem
|
||||
|
||||
import sys
|
||||
import torch
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_text
|
||||
|
||||
# Nasz model to zestaw wag w. Na koniec dojdziemy do modeli
|
||||
# Transformer o wielu milionach wag; w pewnym sensie algorytm
|
||||
# uczenia się nie zmieni.
|
||||
# W naszym zadaniu lepiej zacząć od zerowych wag zamiast losowych.
|
||||
# Tym razem zaznaczamy, że względem w będziemy różniczkować
|
||||
w = torch.zeros(vector_length, dtype=torch.double, requires_grad=True)
|
||||
|
||||
# Hiperparametr uczenia
|
||||
learning_rate = torch.tensor(.0032, dtype=torch.double)
|
||||
|
||||
|
||||
def model(w, x):
|
||||
# @ to iloczyn wektorów/macierzy w PyTorchu
|
||||
return x @ w
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return (y_hat - y_exp)**2
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 5000
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
for line in sys.stdin:
|
||||
content, y_exp = process_line(line)
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
# wartość z predykcji
|
||||
y_hat = model(w, x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
w = w - learning_rate * w.grad
|
||||
closs += loss
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp.item(), " => ", y_hat.item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
# ponownie ustawiamy (i zerujemy) wagi
|
||||
w.requires_grad_(True)
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(w, "model.bin")
|
70
wyk/pytorch-regression/linear1b.py
Executable file
70
wyk/pytorch-regression/linear1b.py
Executable file
@ -0,0 +1,70 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# To samo co linear0.py tylko z automatycznym różniczkowaniem
|
||||
|
||||
import sys
|
||||
import torch
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_text
|
||||
|
||||
# Nasz model to zestaw wag w. Na koniec dojdziemy do modeli
|
||||
# Transformer o wielu milionach wag; w pewnym sensie algorytm
|
||||
# uczenia się nie zmieni.
|
||||
# W naszym zadaniu lepiej zacząć od zerowych wag zamiast losowych.
|
||||
# Tym razem zaznaczamy, że względem w będziemy różniczkować
|
||||
w = torch.zeros(vector_length, dtype=torch.double, requires_grad=True)
|
||||
|
||||
# Hiperparametr uczenia
|
||||
learning_rate = torch.tensor(.0032, dtype=torch.double)
|
||||
|
||||
|
||||
def model(w, x):
|
||||
# @ to iloczyn wektorów/macierzy w PyTorchu
|
||||
return torch.tanh(x @ w)
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return (y_hat - y_exp)**2
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 5000
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
for line in sys.stdin:
|
||||
content, y_exp = process_line(line)
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
# wartość z predykcji
|
||||
y_hat = model(w, x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
w = w - learning_rate * w.grad
|
||||
closs += loss
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp.item(), " => ", y_hat.item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
# ponownie ustawiamy (i zerujemy) wagi
|
||||
w.requires_grad_(True)
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(w, "model.bin")
|
72
wyk/pytorch-regression/linear2.py
Executable file
72
wyk/pytorch-regression/linear2.py
Executable file
@ -0,0 +1,72 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# To samo co linear0.py tylko z automatycznym różniczkowaniem
|
||||
|
||||
import sys
|
||||
import torch
|
||||
from torch import optim
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_text
|
||||
|
||||
# Nasz model to zestaw wag w. Na koniec dojdziemy do modeli
|
||||
# Transformer o wielu milionach wag; w pewnym sensie algorytm
|
||||
# uczenia się nie zmieni.
|
||||
# W naszym zadaniu lepiej zacząć od zerowych wag zamiast losowych.
|
||||
# Tym razem zaznaczamy, że względem w będziemy różniczkować
|
||||
w = torch.zeros(vector_length, dtype=torch.double, requires_grad=True)
|
||||
|
||||
# Tym razem użyjemy optymalizatora
|
||||
optimizer = optim.SGD([w], lr=.0064)
|
||||
|
||||
|
||||
def model(w, x):
|
||||
# @ to iloczyn wektorów/macierzy w PyTorchu
|
||||
return x @ w
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return (y_hat - y_exp)**2
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 5000
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
for line in sys.stdin:
|
||||
optimizer.zero_grad()
|
||||
|
||||
content, y_exp = process_line(line)
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
# wartość z predykcji
|
||||
y_hat = model(w, x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
closs += loss
|
||||
|
||||
# Optymalizator automagicznie zadba o aktualizację wag!
|
||||
optimizer.step()
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp.item(), " => ", y_hat.item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(w, "model.bin")
|
20
wyk/pytorch-regression/linear3-infer.py
Executable file
20
wyk/pytorch-regression/linear3-infer.py
Executable file
@ -0,0 +1,20 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import sys
|
||||
|
||||
from analyzer import midpoint, vectorize_text
|
||||
import torch
|
||||
|
||||
model = torch.load('model.bin')
|
||||
|
||||
|
||||
for line in sys.stdin:
|
||||
line = line.strip('\n')
|
||||
content = line
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
y_hat = model(x)
|
||||
|
||||
# na wyjściu musimy mieć z powrotem rok
|
||||
print(max(1814.0, min(2013.999, y_hat.item() * 100.0 + midpoint)))
|
64
wyk/pytorch-regression/linear3.py
Executable file
64
wyk/pytorch-regression/linear3.py
Executable file
@ -0,0 +1,64 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# To samo co linear0.py tylko z automatycznym różniczkowaniem
|
||||
|
||||
import sys
|
||||
import torch
|
||||
from torch import optim
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_text
|
||||
|
||||
from my_linear_regressor import MyLinearRegressor
|
||||
|
||||
regressor = MyLinearRegressor(vector_length)
|
||||
|
||||
# Tym razem użyjemy optymalizatora
|
||||
optimizer = optim.SGD(regressor.parameters(), lr=.0064)
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return (y_hat - y_exp)**2
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 5000
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
for line in sys.stdin:
|
||||
optimizer.zero_grad()
|
||||
|
||||
content, y_exp = process_line(line)
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
# wartość z predykcji
|
||||
y_hat = regressor(x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
closs += loss
|
||||
|
||||
# Optymalizator automagicznie zadba o aktualizację wag!
|
||||
optimizer.step()
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp.item(), " => ", y_hat.item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(regressor, "model.bin")
|
81
wyk/pytorch-regression/linear4-batches.py
Executable file
81
wyk/pytorch-regression/linear4-batches.py
Executable file
@ -0,0 +1,81 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# Wprowadzamy minibatche
|
||||
|
||||
import sys
|
||||
import torch
|
||||
from torch import optim
|
||||
import itertools
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_batch
|
||||
|
||||
from my_linear_regressor import MyLinearRegressor
|
||||
|
||||
regressor = MyLinearRegressor(vector_length)
|
||||
|
||||
# Rozmiar minibatcha
|
||||
batch_size = 16
|
||||
|
||||
# Pomocnicza funkcja do batchowania
|
||||
def grouper(n, iterable):
|
||||
it = iter(iterable)
|
||||
while True:
|
||||
chunk = tuple(itertools.islice(it, n))
|
||||
if not chunk:
|
||||
return
|
||||
yield chunk
|
||||
|
||||
|
||||
# Tym razem użyjemy optymalizatora
|
||||
optimizer = optim.Adam(regressor.parameters())
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return torch.sum((y_hat - y_exp)**2) / batch_size
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 500
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
for batch in grouper(batch_size, sys.stdin):
|
||||
t = [process_line(line) for line in batch]
|
||||
contents = [entry[0] for entry in t]
|
||||
# y_exp będzie teraz wektorem!
|
||||
y_exp = torch.tensor([entry[1] for entry in t], dtype=torch.double)
|
||||
|
||||
optimizer.zero_grad()
|
||||
|
||||
x = vectorize_batch(contents)
|
||||
|
||||
# wartość z predykcji (też wektor!)
|
||||
y_hat = regressor(x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
closs += loss
|
||||
|
||||
# Optymalizator automagicznie zadba o aktualizację wag!
|
||||
optimizer.step()
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp[0].item(), " => ", y_hat[0].item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(regressor, "model.bin")
|
64
wyk/pytorch-regression/linear4.py
Executable file
64
wyk/pytorch-regression/linear4.py
Executable file
@ -0,0 +1,64 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# To samo co linear0.py tylko z automatycznym różniczkowaniem
|
||||
|
||||
import sys
|
||||
import torch
|
||||
from torch import optim
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_text
|
||||
|
||||
from my_linear_regressor import MyLinearRegressor
|
||||
|
||||
regressor = MyLinearRegressor(vector_length)
|
||||
|
||||
# Tym razem użyjemy optymalizatora
|
||||
optimizer = optim.Adam(regressor.parameters())
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return (y_hat - y_exp)**2
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 5000
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
for line in sys.stdin:
|
||||
optimizer.zero_grad()
|
||||
|
||||
content, y_exp = process_line(line)
|
||||
|
||||
x = vectorize_text(content)
|
||||
|
||||
# wartość z predykcji
|
||||
y_hat = regressor(x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
closs += loss
|
||||
|
||||
# Optymalizator automagicznie zadba o aktualizację wag!
|
||||
optimizer.step()
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp.item(), " => ", y_hat.item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.double, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(regressor, "model.bin")
|
81
wyk/pytorch-regression/linear5.py
Executable file
81
wyk/pytorch-regression/linear5.py
Executable file
@ -0,0 +1,81 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# Wprowadzamy minibatche
|
||||
|
||||
import sys
|
||||
import torch
|
||||
from torch import optim
|
||||
import itertools
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_batch
|
||||
|
||||
from my_linear_regressor2 import MyLinearRegressor2
|
||||
|
||||
# Rozmiar minibatcha
|
||||
batch_size = 16
|
||||
|
||||
regressor = MyLinearRegressor2(vector_length)
|
||||
|
||||
# Pomocnicza funkcja do batchowania
|
||||
def grouper(n, iterable):
|
||||
it = iter(iterable)
|
||||
while True:
|
||||
chunk = tuple(itertools.islice(it, n))
|
||||
if not chunk:
|
||||
return
|
||||
yield chunk
|
||||
|
||||
|
||||
# Tym razem użyjemy optymalizatora
|
||||
optimizer = optim.Adam(regressor.parameters())
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return torch.sum((y_hat - y_exp)**2) / batch_size
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 500
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.float, requires_grad=False)
|
||||
|
||||
for batch in grouper(batch_size, sys.stdin):
|
||||
t = [process_line(line) for line in batch]
|
||||
contents = [entry[0] for entry in t]
|
||||
# y_exp będzie teraz wektorem!
|
||||
y_exp = torch.tensor([entry[1] for entry in t], dtype=torch.float)
|
||||
|
||||
optimizer.zero_grad()
|
||||
|
||||
x = vectorize_batch(contents).float()
|
||||
|
||||
# wartość z predykcji (też wektor!)
|
||||
y_hat = regressor(x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
closs += loss
|
||||
|
||||
# Optymalizator automagicznie zadba o aktualizację wag!
|
||||
optimizer.step()
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp[0].item(), " => ", y_hat[0].item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.float, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(regressor, "model.bin")
|
81
wyk/pytorch-regression/linear6.py
Executable file
81
wyk/pytorch-regression/linear6.py
Executable file
@ -0,0 +1,81 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# Wprowadzamy minibatche
|
||||
|
||||
import sys
|
||||
import torch
|
||||
from torch import optim
|
||||
import itertools
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer import vectorizer, vector_length, process_line, vectorize_batch
|
||||
|
||||
from my_neural_network import MyNeuralNetwork
|
||||
|
||||
# Rozmiar minibatcha
|
||||
batch_size = 16
|
||||
|
||||
regressor = MyNeuralNetwork(vector_length)
|
||||
|
||||
# Pomocnicza funkcja do batchowania
|
||||
def grouper(n, iterable):
|
||||
it = iter(iterable)
|
||||
while True:
|
||||
chunk = tuple(itertools.islice(it, n))
|
||||
if not chunk:
|
||||
return
|
||||
yield chunk
|
||||
|
||||
|
||||
# Tym razem użyjemy optymalizatora
|
||||
optimizer = optim.Adam(regressor.parameters())
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return torch.sum((y_hat - y_exp)**2) / batch_size
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 500
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.float, requires_grad=False)
|
||||
|
||||
for batch in grouper(batch_size, sys.stdin):
|
||||
t = [process_line(line) for line in batch]
|
||||
contents = [entry[0] for entry in t]
|
||||
# y_exp będzie teraz wektorem!
|
||||
y_exp = torch.tensor([entry[1] for entry in t], dtype=torch.float)
|
||||
|
||||
optimizer.zero_grad()
|
||||
|
||||
x = vectorize_batch(contents).float()
|
||||
|
||||
# wartość z predykcji (też wektor!)
|
||||
y_hat = regressor(x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
closs += loss
|
||||
|
||||
# Optymalizator automagicznie zadba o aktualizację wag!
|
||||
optimizer.step()
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp[0].item(), " => ", y_hat[0].item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.float, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(regressor, "model.bin")
|
81
wyk/pytorch-regression/logistic6.py
Executable file
81
wyk/pytorch-regression/logistic6.py
Executable file
@ -0,0 +1,81 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# Wprowadzamy minibatche
|
||||
|
||||
import sys
|
||||
import torch
|
||||
from torch import optim
|
||||
import itertools
|
||||
|
||||
# Preprocessing i wektoryzację tekstów wydzialamy do osobnego modułu,
|
||||
# z którego będzie korzystał zarówno kod do uczenia, jak i predykcji.
|
||||
from analyzer_classification import vectorizer, vector_length, process_line, vectorize_batch
|
||||
|
||||
from my_neural_network import MyNeuralNetwork
|
||||
|
||||
# Rozmiar minibatcha
|
||||
batch_size = 16
|
||||
|
||||
regressor = MyNeuralNetwork(vector_length)
|
||||
|
||||
# Pomocnicza funkcja do batchowania
|
||||
def grouper(n, iterable):
|
||||
it = iter(iterable)
|
||||
while True:
|
||||
chunk = tuple(itertools.islice(it, n))
|
||||
if not chunk:
|
||||
return
|
||||
yield chunk
|
||||
|
||||
|
||||
# Tym razem użyjemy optymalizatora
|
||||
optimizer = optim.Adam(regressor.parameters())
|
||||
|
||||
|
||||
# Funkcja kosztu.
|
||||
def loss_fun(y_hat, y_exp):
|
||||
return torch.sum((y_hat - y_exp)**2) / batch_size
|
||||
|
||||
|
||||
# Co ile kroków będziemy wypisywali informacje o średniej funkcji kosztu.
|
||||
# To nie jest hiperparametr uczenia, nie ma to żadnego, ani pozytywnego, ani
|
||||
# negatywnego wpływu na uczenie.
|
||||
step = 500
|
||||
i = 1
|
||||
closs = torch.tensor(0.0, dtype=torch.float, requires_grad=False)
|
||||
|
||||
for batch in grouper(batch_size, sys.stdin):
|
||||
t = [process_line(line) for line in batch]
|
||||
contents = [entry[0] for entry in t]
|
||||
# y_exp będzie teraz wektorem!
|
||||
y_exp = torch.tensor([entry[1] for entry in t], dtype=torch.float)
|
||||
|
||||
optimizer.zero_grad()
|
||||
|
||||
x = vectorize_batch(contents).float()
|
||||
|
||||
# wartość z predykcji (też wektor!)
|
||||
y_hat = regressor(x)
|
||||
|
||||
# wyliczamy funkcję kosztu
|
||||
loss = loss_fun(y_hat, y_exp)
|
||||
|
||||
loss.backward()
|
||||
|
||||
with torch.no_grad():
|
||||
closs += loss
|
||||
|
||||
# Optymalizator automagicznie zadba o aktualizację wag!
|
||||
optimizer.step()
|
||||
|
||||
# za jakiś czas pokazujemy uśrednioną funkcję kosztu
|
||||
if i % step == 0:
|
||||
print("Sample item: ", y_exp[0].item(), " => ", y_hat[0].item(),
|
||||
" | Avg loss: ", (closs / step).item())
|
||||
closs = torch.tensor(0.0, dtype=torch.float, requires_grad=False)
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
# serializujemy nasz model
|
||||
torch.save(regressor, "model.bin")
|
12
wyk/pytorch-regression/my_linear_regressor.py
Normal file
12
wyk/pytorch-regression/my_linear_regressor.py
Normal file
@ -0,0 +1,12 @@
|
||||
import torch.nn as nn
|
||||
import torch
|
||||
|
||||
|
||||
class MyLinearRegressor(nn.Module):
|
||||
def __init__(self, vlen):
|
||||
super(MyLinearRegressor, self).__init__()
|
||||
self.register_parameter(name='w', param=torch.nn.Parameter(
|
||||
torch.zeros(vlen, dtype=torch.double, requires_grad=True)))
|
||||
|
||||
def forward(self, x):
|
||||
return x @ self.w
|
10
wyk/pytorch-regression/my_linear_regressor2.py
Normal file
10
wyk/pytorch-regression/my_linear_regressor2.py
Normal file
@ -0,0 +1,10 @@
|
||||
import torch.nn as nn
|
||||
|
||||
|
||||
class MyLinearRegressor2(nn.Module):
|
||||
def __init__(self, vlen):
|
||||
super(MyLinearRegressor2, self).__init__()
|
||||
self.w = nn.Linear(vlen, 1, bias=False)
|
||||
|
||||
def forward(self, x):
|
||||
return self.w(x).squeeze()
|
15
wyk/pytorch-regression/my_neural_network.py
Normal file
15
wyk/pytorch-regression/my_neural_network.py
Normal file
@ -0,0 +1,15 @@
|
||||
import torch.nn as nn
|
||||
import torch
|
||||
|
||||
|
||||
class MyNeuralNetwork(nn.Module):
|
||||
def __init__(self, vlen):
|
||||
super(MyNeuralNetwork, self).__init__()
|
||||
self.w1 = nn.Linear(vlen, 1)
|
||||
self.w2 = nn.Linear(vlen, 1)
|
||||
|
||||
self.u1 = torch.nn.Parameter(torch.rand(1, dtype=torch.float, requires_grad=True))
|
||||
self.u2 = torch.nn.Parameter(torch.rand(1, dtype=torch.float, requires_grad=True))
|
||||
|
||||
def forward(self, x):
|
||||
return self.u1 * torch.nn.functional.tanh(self.w1(x).squeeze()) + self.u2 * torch.nn.functional.tanh(self.w2(x).squeeze())
|
Loading…
Reference in New Issue
Block a user