tangram_linear 0.7.0

Tangram makes it easy for programmers to train, deploy, and monitor machine learning models.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

import torch
import torch.nn as nn
import numpy as np
from torch.utils.data import DataLoader, TensorDataset, random_split

class LinearRegressor(nn.Module):
  def __init__(self, batch_size=1, n_epochs=10, learning_rate=0.01):
    super().__init__()
    self.n_epochs = n_epochs
    self.learning_rate = learning_rate
    self.batch_size = batch_size

  def forward(self, x):
    return self.linear(x)

  def fit(self, features_train, labels_train):
    n_features = features_train.shape[1]
    self.linear = nn.Linear(n_features, 1)
    features_train_tensor = torch.from_numpy(features_train).type(torch.float32)
    labels_train_tensor = torch.unsqueeze(torch.from_numpy(labels_train.to_numpy()).type(torch.float32), 1)
    features_train = TensorDataset(features_train_tensor, labels_train_tensor)
    train_loader = DataLoader(features_train, self.batch_size, shuffle=True)
    loss_fn = torch.nn.MSELoss()
    optimizer = torch.optim.SGD(self.parameters(), self.learning_rate)
    for epoch in range(self.n_epochs):
      for batch in train_loader:
        inputs, labels = batch
        optimizer.zero_grad()
        outputs = self(inputs)
        loss = loss_fn(outputs, labels)
        loss.backward()
        optimizer.step()

  def predict(self, features_test):
    features_test_tensor = torch.from_numpy(features_test).type(torch.float32)
    features_test = TensorDataset(features_test_tensor)
    test_loader = iter(DataLoader(features_test, batch_size=len(features_test)))
    with torch.no_grad():
      data = test_loader.next()
      inputs = data[0]
      outputs = self(inputs)
      predictions = outputs.data.numpy().flatten()
      return predictions

class LinearBinaryClassifier(nn.Module):
  def __init__(self, batch_size=1, n_epochs=10, learning_rate=0.01):
    super().__init__()
    self.n_epochs = n_epochs
    self.learning_rate = learning_rate
    self.batch_size = batch_size

  def forward(self, x):
    x = self.linear(x)
    out = nn.Sigmoid()(x)
    return out

  def fit(self, features_train, labels_train):
    n_features = features_train.shape[1]
    self.linear = nn.Linear(n_features, 1)
    features_train_tensor = torch.from_numpy(features_train).type(torch.float32)
    labels_train_tensor = torch.unsqueeze(torch.from_numpy(labels_train.to_numpy()).type(torch.float32), 1)
    features_train = TensorDataset(features_train_tensor, labels_train_tensor)
    train_loader = DataLoader(features_train, self.batch_size, shuffle=True)
    loss_fn = nn.BCELoss()
    optimizer = torch.optim.SGD(self.parameters(), self.learning_rate)
    for epoch in range(self.n_epochs):
      for batch in train_loader:
        inputs, labels = batch
        optimizer.zero_grad()
        outputs = self(inputs)
        loss = loss_fn(outputs, labels)
        loss.backward()
        optimizer.step()

  def predict_proba(self, features_test):
    features_test_tensor = torch.from_numpy(features_test).type(torch.float32)
    features_test = TensorDataset(features_test_tensor)
    test_loader = iter(DataLoader(features_test, batch_size=len(features_test)))
    with torch.no_grad():
      data = test_loader.next()
      inputs = data[0]
      outputs = self(inputs)
      predictions = outputs.data.numpy().flatten()
      return predictions

class LinearMulticlassClassifier(nn.Module):
  def __init__(self, batch_size=1, n_epochs=10, learning_rate=0.01, n_classes=3):
    super().__init__()
    self.n_epochs = n_epochs
    self.learning_rate = learning_rate
    self.batch_size = batch_size
    self.n_classes = n_classes

  def forward(self, x):
    x = self.linear(x)
    out = nn.Softmax(dim=1)(x)
    return out

  def fit(self, features_train, labels_train):
    n_features = features_train.shape[1]
    self.linear = nn.Linear(n_features, self.n_classes)
    features_train_tensor = torch.from_numpy(features_train).type(torch.float32)
    labels_train_tensor = torch.from_numpy(labels_train.to_numpy()).type(torch.int64)
    features_train = TensorDataset(features_train_tensor, labels_train_tensor)
    train_loader = DataLoader(features_train, self.batch_size, shuffle=True)
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(self.parameters(), self.learning_rate)
    for epoch in range(self.n_epochs):
      for batch in train_loader:
        inputs, labels = batch
        optimizer.zero_grad()
        outputs = self(inputs)
        loss = loss_fn(outputs, labels)
        loss.backward()
        optimizer.step()

  def predict(self, features_test):
    features_test_tensor = torch.from_numpy(features_test).type(torch.float32)
    features_test = TensorDataset(features_test_tensor)
    test_loader = iter(DataLoader(features_test, batch_size=len(features_test)))
    with torch.no_grad():
      data = test_loader.next()
      inputs = data[0]
      outputs = self(inputs)
      _, predictions = torch.max(outputs.data, 1)
      return predictions