---
license: mit
tags:
- Classification
- Классификация
- Классификатор
- Classifier
- Temperature
- Температура
- Классификации
- Numbers
- Числа
- Numbers classification
- Simple
- class
- класс
- negative
- positive
- digit
- разряд
- негативный
- позитивный
- torch
- pytorch
---
A simple linear temperature classifier that determines whether it is negative or positive.

**0** - negative temperature

**1** - positive temperature

**Model architecture**
```python
import torch
import torch.nn as nn

class TemperatureClassifier(nn.Module):
    def __init__(self, inp_dim, hidden_dim, out_dim):
        super().__init__()
        self.ln_1 = nn.Linear(inp_dim, hidden_dim)
        self.ln_out = nn.Linear(hidden_dim, out_dim)
        self.gelu = nn.GELU()

    def forward(self, x):
        out1 = self.gelu(self.ln_1(x))
        out2 = self.ln_out(out1)

        return out2

```

**Model train example**
```python
import torch
import torch.nn as nn
from model import TemperatureClassifier
from safetensors.torch import save_file
    
def split_data(dictionary):
    x  = []
    y = []

    x = list(dictionary.keys())
    y = list(dictionary.values())

    return x, y

def load_tensor(x, y, device):
    x_tensor = torch.tensor(x, dtype=torch.float32).unsqueeze(1).to(device)
    y_tensor = torch.tensor(y, dtype=torch.int64).to(device)

    return x_tensor, y_tensor

def validation(model, x_val_ten, y_val_ten):
    loss_fn = nn.CrossEntropyLoss()
    model.eval()
    count = 0
    avg_val_loss = 0

    with torch.no_grad():
        for i in range(len(x_val_ten)):
            x_sm = x_val_ten[i].unsqueeze(0)
            y_sm = y_val_ten[i].unsqueeze(0)
            out = model(x_sm)
            loss = loss_fn(out, y_sm)
            avg_val_loss += loss.item()
            count += 1

    avg_val_loss = avg_val_loss / count
    print(f'Avg val loss: {avg_val_loss}')


def learning(model, x_train_ten, y_train_ten, x_test_ten, y_test_ten, x_val_ten, y_val_ten, epoch=8):
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-3)
    loss_fn = nn.CrossEntropyLoss()
   
    count = 0
    avg_train_loss = 0
    avg_test_loss = 0

    for i in range(epoch):
        model.train()
        print(f'Эпоха: {i}')
        optimizer.zero_grad()
        for j in range(len(x_train_ten)):
            x_sample = x_train_ten[j].unsqueeze(0)
            y_sample = y_train_ten[j].unsqueeze(0)

            out = model(x_sample)
            loss = loss_fn(out, y_sample)
            avg_train_loss += loss.item()
            count += 1
            loss.backward()
            optimizer.step()
            optimizer.zero_grad()
        
        avg_train_loss = avg_train_loss / count
        count = 0
        print(f'Avg train loss: {avg_train_loss}')
        avg_train_loss = 0
        
        model.eval()
        avg_test_loss = 0
        with torch.no_grad():
            for j in range(len(x_test_ten)):
                x_sm = x_test_ten[j].unsqueeze(0)
                y_sm = y_test_ten[j].unsqueeze(0)
                out = model(x_sm)
                loss = loss_fn(out, y_sm)
                avg_test_loss += loss.item()
                count += 1
        
        avg_test_loss = avg_test_loss / count
        print(f'Avg test loss: {avg_test_loss}')
        count = 0
        avg_train_loss = 0
        avg_test_loss = 0

    
    validation(model, x_val_ten, y_val_ten)

    save_file(model.state_dict(), 'temperature_classifier.safetensors')
    print('Model temperature_classifier.safetensors saved')

train_data = {
    # ===== Class 0: Negative numbers =====
    -1: 0, -5: 0, -10: 0, -0.5: 0, -12.5: 0, -30.5: 0,
    -15.2: 0, -11: 0, -0.05: 0, -0.15: 0, -100: 0,
    -35: 0, -0.02: 0, -0.01: 0, -34.4: 0, -44.5: 0,
    -1000: 0, -1110: 0, -5.5: 0, -4.5: 0, -11.4: 0,
    -345: 0, -222: 0, -145: 0, -289678: 0, -93949585: 0,
    -3456666: 0, -0.0045: 0, -0.99: 0, -0.0000000006: 0, -0.00000003: 0, -0.000034:0,  -0.0000000455: 0, -0.0000005666: 0, -0.0000056054: 0, -0.00000455: 0, -0.0000045: 0, -0.00000000432:0, -0.007: 0, -0.0000056: 0, -0.00000644: 0, -0.0000005444: 0,
    # ===== Class 1: Positive numbers =====
    123: 1, 23.4: 1, 56.6: 1, 0.05: 1, 0.01: 1,
    1: 1, 156: 1, 1111: 1, 566: 1, 13.5: 1,
    89.3: 1, 894: 1, 990: 1, 34.5: 1, 12.4: 1,
    134: 1, 90: 1, 543: 1, 15.7: 1, 10.5: 1,
    777: 1, 855: 1, 989789: 1, 344.1: 1, 4545454545: 1,
    0.034: 1, 0.89: 1, 0.99: 1, 0.78: 1, 0.17: 1,
    0.1455: 1, 0.035: 1, 0.00000005: 1, 0.000003:1, 0.0000007: 1, 0.0000002: 1, 0.0000000677: 1, 0.000000000455: 1, 0.0000000006775: 1, 0.000004554: 1, 0.000001344: 1, 0.000000345: 1, 0.000000340: 1, 0.000554: 1, 0.00000005565: 1, 0.000000456: 1, 0.00000005434: 1
}

test_data = {
    # ===== Class 0 =====
    -111: 0, -3450: 0, -9: 0, -789: 0,
    -12000: 0, -8984: 0, -1030: 0, -256897: 0,
    -0.1: 0, -0.002: 0, -0.007: 0,-0.00000034:0,-0.0000345: 0, -0.000000056777: 0,
    

    # ===== Class 2 =====
    9999: 1, 1456: 1, 12000: 1, 11000: 1,
    1060: 1, 456: 1, 888: 1, 111: 1, 100940: 1, 0.0000000345: 1, 0.00000000456: 1, 0.00000000545: 1
}

validation_data = {
    # ===== Class 0 =====
    -999: 0, -123345: 0, -9999999: 0, -3: 0, -67: 0,
    -77: 0, -456789: 0, -77777: 0, -88.56: 0, -567.78: 0,
    -55.33: 0, -980.3: 0, -134.23: 0, -989456: 0, -345566: 0,
    -1.1235: 0, -10: 0, -0.01: 0, -0.22: 0, -0.12: 0, -0.155: 0, -0.0000004: 0, -0.000000023: 0, -0.000000000504: 0, -0.000000056: 0,
    
    
    # ===== Class 2 =====
    1956933: 1, 898422: 1, 76: 1, 555: 1,
    22222: 1, 123456: 1, 777777: 1, 1: 1,
    3: 1, 4: 1, 5: 1, 19: 1, 19.5: 1,
    0.11: 1, 0.21: 1, 0.34: 1, 0.45: 1,
    0.111: 1, 1.111: 1, 9999999: 1, 955665455: 1,
    2345677: 1, 765456: 1, 0.0000034: 1, 0.0000000006:1, 0.00000000355: 1, 0.00000000006504: 1, 0.0000003455: 1
}

device = ('cuda' if torch.cuda.is_available() else 'cpu')

x_train = []
y_train = []

x_test = []
y_test = []

x_val = []
y_val = []

mean = 0
std = 0


model = TemperatureClassifier(1, 100, 2).to(device)

x_train, y_train = split_data(train_data)

x_test, y_test = split_data(test_data)

x_val, y_val = split_data(validation_data)

x_train_ten, y_train_ten = load_tensor(x_train, y_train, device)

x_test_ten, y_test_ten = load_tensor(x_test, y_test, device)

x_val_ten, y_val_ten = load_tensor(x_val, y_val, device)


learning(model, x_train_ten, y_train_ten, x_test_ten, y_test_ten, x_val_ten, y_val_ten, epoch=4000)
```
**Inference example**

```python
import torch
import torch.nn as nn
from model import TemperatureClassifier
from safetensors.torch import load_file

dic =  load_file('temperature_classifier.safetensors')

device = ('cuda' if torch.cuda.is_available() else 'cpu')

model = TemperatureClassifier(1, 100, 2).to(device)
model.load_state_dict(dic)

print(dic)


print("Write the temperature: ")
x = float(input())

x_tensor = torch.tensor([[x]], dtype=torch.float32).to(device)

model.eval()
with torch.no_grad():
    logits = model(x_tensor)
    print(logits)
    out = torch.argmax(logits, dim=1)
    
print(out.item())
```