diff --git a/boston-house-price-prediction/REAME.md b/boston-house-price-prediction/REAME.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ca09f0f7480f5b18de4ca4b43dfb55a7dcfc246
--- /dev/null
+++ b/boston-house-price-prediction/REAME.md
@@ -0,0 +1,3 @@
+# Disclaymer
+
+This model is wrong and it is bad. The correct prediction should be: "Delete this project!".
diff --git a/boston-house-price-prediction/main.py b/boston-house-price-prediction/main.py
index af8f24e9b800a6a1a420111747027a805122d471..9ec034af49993f6f920403b6d13c69a7b19e4aa1 100644
--- a/boston-house-price-prediction/main.py
+++ b/boston-house-price-prediction/main.py
@@ -2,9 +2,10 @@ import numpy as np
 import torch
 import torch.nn as nn
 from torch.utils.data.sampler import SubsetRandomSampler
-from pad import PadCollate
 from dataset import BostonDataset
 from network import NeuralNetwork
+import progressbar
+
 
 dataset = BostonDataset("dataset.csv")
 dataset_size = len(dataset)
@@ -26,24 +27,37 @@ test_sampler = SubsetRandomSampler(test_indices)
 train_loader = torch.utils.data.DataLoader(
     dataset, batch_size=batch_size, sampler=train_sampler
 )
-test_loader = torch.utils.data.DataLoader(
-    dataset, batch_size=batch_size, sampler=test_sampler
-)
+test_loader = torch.utils.data.DataLoader(dataset, batch_size=1, sampler=test_sampler)
 
-model = NeuralNetwork([8, 16, 8])
+model = NeuralNetwork([8, 32, 32, 16])
 model.cuda()
 
 loss_function = nn.MSELoss()
 optimization_function = torch.optim.Adam(
-    model.parameters(), lr=0.01, betas=(0.99, 0.995), weight_decay=0
+    model.parameters(), lr=0.01, betas=(0.99, 0.995), weight_decay=0.1
 )
 
 model.train()
-num_epochs = 10
-for _ in range(num_epochs):
+num_epochs = 1000
+for _ in progressbar.progressbar(range(num_epochs)):
     for batch_index, (x, y) in enumerate(train_loader):
         optimization_function.zero_grad()
         y_predicted = model(x)
-        loss = loss_function(y_predicted.float(), y)
-        loss.backward()
+        error = loss_function(y_predicted.float(), y)
+        error.backward()
         optimization_function.step()
+
+model.eval()
+with torch.no_grad():
+    # predicted_values = torch.tensor([]).cuda()
+    # correct_values = torch.tensor([]).cuda()
+    for batch_index, (x, y) in enumerate(test_loader):
+        y_predicted = model(x)
+        error = loss_function(y_predicted.float(), y)
+        print(f"Error: {error}; Prediction: {y_predicted}; Correct: {y}")
+        # predicted_values = torch.cat((predicted_values, y_predicted), -1)
+        # correct_values = torch.cat((correct_values, y), -1)
+
+    # print(predicted_values.cpu().numpy()[0])
+    # print(correct_values.cpu().numpy()[0])
+    # print(accuracy)
diff --git a/boston-house-price-prediction/network.py b/boston-house-price-prediction/network.py
index 2d6174d1db11b6ceb42bacb0448f962755146332..59ceb3f08651437fd8eec6c39d62a2c522c8159f 100644
--- a/boston-house-price-prediction/network.py
+++ b/boston-house-price-prediction/network.py
@@ -12,7 +12,9 @@ class NeuralNetwork(nn.Module):
             nn.ReLU(),
             nn.Linear(hidden_layers_size[1], hidden_layers_size[2]),
             nn.ReLU(),
-            nn.Linear(hidden_layers_size[2], 1),
+            nn.Linear(hidden_layers_size[2], hidden_layers_size[3]),
+            nn.ReLU(),
+            nn.Linear(hidden_layers_size[3], 1),
         )
 
     def forward(self, x):