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