Review test: artificial intelligence

# Review test, task 1: k-NN without libraries
# Data: (hours of study per week, hours of sleep per night) -> whether the student passed the test
import math

train = [
    ((2, 6), "no"), ((1, 7), "no"), ((3, 5), "no"),
    ((2, 8), "no"), ((4, 6), "no"),
    ((6, 8), "yes"), ((7, 7), "yes"), ((5, 9), "yes"),
    ((8, 8), "yes"), ((6, 7), "yes"),
]
test = [((3, 7), "no"), ((7, 9), "yes"),
           ((5, 6), "yes"), ((1, 9), "no")]


def distance(a, b):
    """Euclidean distance between two points."""
    return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)


def predict(point, k=3):
    """Return the answer that the majority of the k nearest examples have."""
    nearest = sorted(train, key=lambda p: distance(point, p[0]))[:k]
    votes = {}
    for _, answer in nearest:
        votes[answer] = votes.get(answer, 0) + 1
    return max(votes, key=votes.get)


correct = 0
for point, actual in test:
    p = predict(point)
    print(point, "predicted:", p, "| actual:", actual)
    if p == actual:
        correct += 1
print("Accuracy:", correct, "of", len(test))

Program output:

(3, 7) predicted: no | actual: no
(7, 9) predicted: yes | actual: yes
(5, 6) predicted: no | actual: yes
(1, 9) predicted: no | actual: no
Accuracy: 3 of 4

Answer to the question: the model makes a mistake for (5, 6). Among the three nearest examples, two are “no” ((4, 6) and (3, 5)) and only one is “yes” ((6, 7)), so the majority says “no”. The point lies on the border between the groups and there are few training examples – with more data or a different k the result could be different.

# Review test, task 2: a decision tree for the classroom
from sklearn.tree import DecisionTreeClassifier, export_text

# (temperature in °C, humidity in %) -> state of the classroom
X = [[17.5, 50], [18.2, 45], [19.0, 60], [20.5, 48], [21.0, 52], [22.3, 47],
     [23.0, 55], [21.8, 74], [22.5, 78], [20.9, 80], [25.2, 50], [26.8, 45], [27.5, 60]]
y = ["cold", "cold", "cold", "pleasant", "pleasant", "pleasant",
     "pleasant", "stuffy", "stuffy", "stuffy", "warm", "warm", "warm"]

model = DecisionTreeClassifier(max_depth=3, random_state=0)   # a small tree – easy to read
model.fit(X, y)
print(export_text(model, feature_names=["temperature", "humidity"]))

for measurement in [[19.5, 50], [22.0, 76], [26.0, 40]]:
    print(measurement, "->", model.predict([measurement])[0])

Program output:

|--- humidity <= 67.00
|   |--- temperature <= 19.75
|   |   |--- class: cold
|   |--- temperature >  19.75
|   |   |--- temperature <= 24.10
|   |   |   |--- class: pleasant
|   |   |--- temperature >  24.10
|   |   |   |--- class: warm
|--- humidity >  67.00
|   |--- class: stuffy

[19.5, 50] -> cold
[22.0, 76] -> stuffy
[26.0, 40] -> warm

The same tree, rewritten as a function:

# Review test, task 2b: the tree rewritten as an ordinary function (if – else)
def state(temperature, humidity):
    if humidity <= 67:
        if temperature <= 19.75:
            return "cold"
        elif temperature <= 24.1:
            return "pleasant"
        else:
            return "warm"
    else:
        return "stuffy"


print(state(19.5, 50), state(22.0, 76), state(26.0, 40))

Program output:

cold stuffy warm

Version for the ESP32 (C++):

// Review test, task 2b (ESP32 version): the same rules as a C++ function
const char* state(float temperature, float humidity) {
  if (humidity <= 67) {
    if (temperature <= 19.75) return "cold";
    else if (temperature <= 24.1) return "pleasant";
    else return "warm";
  }
  return "stuffy";
}

Check: the function gives the same answer as the trained model on 3,250 measurements (temperatures from 15 to 30 °C, humidity from 30 to 94%).

Answer to the question: the tree has only a few comparisons, so it fits into the small memory of the ESP32 and works instantly; a person can read and check it. A large neural network has thousands of weights and needs much more memory and computation (see TinyML).