{"id":1493,"date":"2023-09-26T21:02:34","date_gmt":"2023-09-26T19:02:34","guid":{"rendered":"http:\/\/blog.schmoigl-online.de\/?p=1493"},"modified":"2023-09-26T23:21:04","modified_gmt":"2023-09-26T21:21:04","slug":"tic-tac-toe-and-ai-a-winning-board","status":"publish","type":"post","link":"http:\/\/blog.schmoigl-online.de\/?p=1493","title":{"rendered":"Tic-Tac-Toe and AI: A Winning Board (Part 2)"},"content":{"rendered":"\n

As a first learning task for using AI with Tic-Tac-Toe, let us take the task of determining whether a board is a winning one or not (i.e. either X or O has won the game). We cannot directly tell the neural network what the rules are for an assignment to be winning. Instead, we need to train it by examples. For that we already have prepared some data in a previous post<\/a>.<\/p>\n\n\n\n

The idea is a to train a TensorFlow model with several Dense layers. By varying the model’s configuration, we want to determine how complex (e.g. how many parameters we need) such a model needs to be to fulfill this requirement. Also looking at the accuracy will be an interesting topic.<\/p>\n\n\n\n

As an information in advance: The computation were done using TensorFlow 2.13.1 on a Windows WSL2 machine having an NVIDIA Geforce RTX 4060 (8GB) installed. Mixed Precision<\/a> was not enabled.<\/p>\n\n\n\n

As usual you may download the entire example using the following link:<\/p>\n\n\n

\"\"  tictactoetf.zip<\/a><\/strong> (9.6 KiB, 1,132 hits)<\/p>\n\n\n\n

Let’s get started…<\/p>\n\n\n\n

[continued on the next page]<\/p>\n\n\n\n\n\n\n\n

Reading Data for Training and Evaluation<\/h2>\n\n\n\n

First of all, we need to read the data for training and evaluation. In the preparation blog post, we already created the test data file tictactoe_valid.txt<\/code> for that. We will reuse the data loader for further cases as well, that is why we build it a little generic using Pyrecord<\/a>s.<\/p>\n\n\n\n

import gzip\nfrom pyrecord import Record # https:\/\/pythonhosted.org\/pyrecord\/\n\nimport itertools<\/code><\/pre>\n\n\n\n
TTTRecord = Record.create_type(\"TTTRecord\", \"vector\", \"valid\", \"winning\", \"winner\", \"move\")<\/code><\/pre>\n\n\n\n
def tttRecordGenerator():\n    with open(\"tictactoe_valid.txt\", \"rt\") as f:\n        line = f.readline()\n        while line:\n            # print (line)\n            vector = [int(line[0]), int(line[1]), int(line[2]), int(line[3]), int(line[4]), int(line[5]), int(line[6]), int(line[7]), int(line[8])]\n            valid = line[10] == \"1\"\n            winning = int(line[11])\n            winner = int(line[12])\n            move = int(line[13])\n            record = TTTRecord(vector, valid, winning, winner, move)\n            yield record\n            line = f.readline()<\/code><\/pre>\n\n\n\n
validtttRecords = filter(lambda o : o.valid, tttRecordGenerator())<\/code><\/pre>\n\n\n\n
# Warning: will take a couple of seconds!\nvalidtttRecordsList = list(validtttRecords)\nlen(validtttRecordsList)<\/code><\/pre>\n\n\n\n
Having set up TensorFlow with<\/p>\n\n\n\n
import os\nos.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tensorflow.keras.layers.experimental import preprocessing\n\nimport pandas as pd\nimport numpy as np\nimport datetime<\/code><\/pre>\n\n\n\n
we then transform or Pyrecord data into a Pandas DataFrame.<\/p>\n\n\n\n
allDataFrame = pd.DataFrame(list(zip([x.vector[0] for x in validtttRecordsList], \n                                     [x.vector[1] for x in validtttRecordsList],\n                                     [x.vector[2] for x in validtttRecordsList],\n                                     [x.vector[3] for x in validtttRecordsList],\n                                     [x.vector[4] for x in validtttRecordsList],\n                                     [x.vector[5] for x in validtttRecordsList],\n                                     [x.vector[6] for x in validtttRecordsList],\n                                     [x.vector[7] for x in validtttRecordsList],\n                                     [x.vector[8] for x in validtttRecordsList],\n                                     [x.winning for x in validtttRecordsList])), \n             columns =['pos1', 'pos2', 'pos3','pos4','pos5','pos6','pos7','pos8','pos9', 'winning'])\n\nprint(allDataFrame.tail())<\/code><\/pre>\n\n\n\n
This gives us a first glimpse of the data:<\/p>\n\n\n\n
        pos1  pos2  pos3  pos4  pos5  pos6  pos7  pos8  pos9  winning\n362875     9     8     7     6     5     4     1     3     2        1\n362876     9     8     7     6     5     4     2     1     3        0\n362877     9     8     7     6     5     4     2     3     1        0\n362878     9     8     7     6     5     4     3     1     2        1\n362879     9     8     7     6     5     4     3     2     1        1<\/code><\/pre>\n\n\n\n
Essentially, what we are doing is that we unpack the vector into columns (this will be our features later on), having it located next to the winning information (which will be our labels later).<\/p>\n\n\n\n
Training (Basic Model)<\/h2>\n\n\n\n
For training, we take the usual 80% random cut. The remainder will serve as test for evaluation later. Moreover, we take the usual statistical information for our training set.
<\/p>\n\n\n\n
train_dataset = allDataFrame.sample(frac=0.8, random_state=42)\ntest_dataset = allDataFrame.drop(train_dataset.index)\n\nprint(allDataFrame.shape, train_dataset.shape, test_dataset.shape)\ntrain_dataset.describe().transpose()<\/code><\/pre>\n\n\n\n
(362880, 10) (290304, 10) (72576, 10)<\/code><\/pre>\n\n\n\n
<\/th>count<\/th>mean<\/th>std<\/th>min<\/th>25%<\/th>50%<\/th>75%<\/th>max<\/th><\/tr><\/thead>
pos1<\/th>290304.0<\/td>5.004037<\/td>2.582516<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos2<\/th>290304.0<\/td>4.999249<\/td>2.580750<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos3<\/th>290304.0<\/td>4.996063<\/td>2.580538<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos4<\/th>290304.0<\/td>5.003014<\/td>2.581781<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos5<\/th>290304.0<\/td>4.996579<\/td>2.582223<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos6<\/th>290304.0<\/td>5.000279<\/td>2.581773<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos7<\/th>290304.0<\/td>4.999029<\/td>2.583215<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos8<\/th>290304.0<\/td>4.998505<\/td>2.581489<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
pos9<\/th>290304.0<\/td>5.003245<\/td>2.583642<\/td>1.0<\/td>3.0<\/td>5.0<\/td>7.0<\/td>9.0<\/td><\/tr>
winning<\/th>290304.0<\/td>0.448692<\/td>0.497361<\/td>0.0<\/td>0.0<\/td>0.0<\/td>1.0<\/td>1.0<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
We can easily see that there is a uniform distribution on all positions, and that the winning value behaves like a boolean for categorization.<\/p>\n\n\n\n
For easier access, we can now split features and labels:<\/p>\n\n\n\n
# split features from labels\ntrain_features = train_dataset.copy()\ntest_features = test_dataset.copy()\n\ntrain_labels = train_features.pop('winning')\ntest_labels = test_features.pop('winning')<\/code><\/pre>\n\n\n\n
Obviously our features are not normalized yet. That is why we prepare a Keras Normalization Layer.<\/p>\n\n\n\n
normalizer = preprocessing.Normalization()\nnormalizer.adapt(np.array(train_features))\nprint(normalizer.mean.numpy())<\/code><\/pre>\n\n\n\n
[[5.004032  4.9992476 4.9960785 5.0030107 4.9965568 5.0002723 4.999036\n  4.9984956 5.0032406]]<\/code><\/pre>\n\n\n\n
Soon we will make this the first layer of our model.<\/p>\n\n\n\n
Apropos talking about the model: For a starter, let’s take the following model:<\/p>\n\n\n\n
model = keras.models.Sequential([\n    normalizer,\n    layers.Dense(units=64, activation='relu'), #1\n    layers.Dense(units=64,activation='relu'), #2 \n    layers.Dense(units=128,activation='relu'), #3\n    layers.Dense(units=1)\n])\nprint(model.summary())<\/code><\/pre>\n\n\n\n
Model: \"sequential\"\n_________________________________________________________________\n Layer (type)                Output Shape              Param #   \n=================================================================\n normalization (Normalizati  (None, 9)                 19        \n on)                                                             \n                                                                 \n dense (Dense)               (None, 64)                640       \n                                                                 \n dense_1 (Dense)             (None, 64)                4160      \n                                                                 \n dense_2 (Dense)             (None, 128)               8320      \n                                                                 \n dense_3 (Dense)             (None, 1)                 129       \n                                                                 \n=================================================================\nTotal params: 13268 (51.83 KB)\nTrainable params: 13249 (51.75 KB)\nNon-trainable params: 19 (80.00 Byte)\n_________________________________________________________________\nNone<\/code><\/pre>\n\n\n\n
As you can see, after the normalizer, we have two Dense layers with 64 units each, followed by a Dense layer with 128 units. As we want to have a single boolean-like result (“winning or not”), the result layer is a Dense layer with a single unit. As we go with the logit approach, there is no activation function on the result layer. Let’s see how far we get with this. <\/p>\n\n\n\n
To ensure that we don’t overfit our model, let’s make sure that we will stop fitting at latest, if we have an accuracy of 1.0. For that we define a brief custom fitting callback:<\/p>\n\n\n\n
class Accuracy1Stopping(keras.callbacks.Callback):\n    def __init():\n        super.__init__()\n\n    def on_epoch_end(self, epoch, logs=None):\n        if round(logs.get('accuracy'), 4) == 1.0:\n            self.model.stop_training = True<\/code><\/pre>\n\n\n\n
Then let’s compile and fit the model right away:<\/p>\n\n\n\n
model.compile(loss=keras.losses.BinaryCrossentropy(from_logits=True),\n              optimizer=keras.optimizers.Adam(learning_rate=0.01), \n              metrics = [\"accuracy\"])<\/code><\/pre>\n\n\n\n
history = model.fit(train_features, train_labels, \n          batch_size=512, \n          epochs=20, \n          shuffle=True,\n          callbacks=[\n              tf.keras.callbacks.EarlyStopping(monitor='accuracy', mode=\"max\", restore_best_weights=True, patience=5, verbose=1), \n              Accuracy1Stopping(),\n              tf.keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=0.2, patience=2, min_lr=0.002)\n          ], \n          verbose=1)<\/code><\/pre>\n\n\n\n
Epoch 1\/50\n567\/567 [==============================] - 6s 7ms\/step - loss: 0.5521 - accuracy: 0.6821 - lr: 0.0100\nEpoch 2\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.3881 - accuracy: 0.7986 - lr: 0.0100\nEpoch 3\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.2644 - accuracy: 0.8709 - lr: 0.0100\nEpoch 4\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.1828 - accuracy: 0.9161 - lr: 0.0100\nEpoch 5\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.1332 - accuracy: 0.9435 - lr: 0.0100\nEpoch 6\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0902 - accuracy: 0.9631 - lr: 0.0100\nEpoch 7\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0713 - accuracy: 0.9716 - lr: 0.0100\nEpoch 8\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0696 - accuracy: 0.9740 - lr: 0.0100\nEpoch 9\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0528 - accuracy: 0.9808 - lr: 0.0100\nEpoch 10\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0445 - accuracy: 0.9841 - lr: 0.0100\nEpoch 11\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0496 - accuracy: 0.9836 - lr: 0.0100\nEpoch 12\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0285 - accuracy: 0.9907 - lr: 0.0100\nEpoch 13\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0433 - accuracy: 0.9860 - lr: 0.0100\nEpoch 14\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0181 - accuracy: 0.9955 - lr: 0.0100\nEpoch 15\/50\n567\/567 [==============================] - 3s 6ms\/step - loss: 0.0552 - accuracy: 0.9852 - lr: 0.0100\nEpoch 16\/50\n567\/567 [==============================] - 3s 6ms\/step - loss: 0.0022 - accuracy: 0.9999 - lr: 0.0100\nEpoch 17\/50\n567\/567 [==============================] - 3s 6ms\/step - loss: 0.0032 - accuracy: 0.9995 - lr: 0.0100\nEpoch 18\/50\n567\/567 [==============================] - 3s 6ms\/step - loss: 0.0914 - accuracy: 0.9779 - lr: 0.0100\nEpoch 19\/50\n567\/567 [==============================] - 3s 5ms\/step - loss: 0.0030 - accuracy: 0.9999 - lr: 0.0020\nEpoch 20\/50\n567\/567 [==============================] - 3s 6ms\/step - loss: 0.0022 - accuracy: 1.0000 - lr: 0.0020\n\n<\/code><\/pre>\n\n\n\n
Note that the training was through in less than 63s – and we achieved a mind-blowing accuracy of 1.0 after already 20 epochs!<\/p>\n\n\n\n
Evaluation (Basic Model)<\/h2>\n\n\n\n
Let’s check whether the model has not tried to trick us and use the test dataset:<\/p>\n\n\n\n
evaluationResult = model.evaluate(test_features, test_labels, batch_size=256, verbose=1)\nprint(evaluationResult)<\/code><\/pre>\n\n\n\n
284\/284 [==============================] - 4s 10ms\/step - loss: 0.0021 - accuracy: 1.0000\n[0.002135399729013443, 1.0]<\/code><\/pre>\n\n\n\n
Also for test dataset, the accuracy is 1.0! That impressively confirms that the neural network was able to learn what a winning board is.<\/p>\n\n\n\n
BTW: This Keras neural network can be downloaded here.<\/p>\n\n\n
\"\"  tic-tac-toe-Winning-Model.zip<\/a><\/strong> (134.8 KiB, 861 hits)<\/p>\n\n\n\n
Sensitive Analysis<\/h2>\n\n\n\n
Now, let’s play around a little with the model and see how sensitive our model configuration is. For that, we automate the evaluation in a function, which reads like this:<\/p>\n\n\n\n
import time\ndef runTrainingAndMeasureTestAccuracy(model, learning_rate): \n    model.compile(loss=keras.losses.BinaryCrossentropy(from_logits=True),\n              optimizer=keras.optimizers.Adam(learning_rate=learning_rate), \n              metrics = [\"accuracy\"])\n    start = time.time()\n    history = model.fit(train_features, train_labels, \n          batch_size=512, \n          epochs=50, \n          shuffle=True, \n          callbacks=[\n              tf.keras.callbacks.EarlyStopping(monitor='accuracy', mode=\"max\", patience=5, verbose=1), \n              Accuracy1Stopping(),\n              tf.keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=0.2, patience=2, min_lr=0.002)\n          ],\n          verbose=1)\n    stop = time.time()\n    print(f\"Elapsed Training time: {stop-start}\")\n\n    print(\"Evaluating...\")\n    evaluationResult = model.evaluate(test_features, test_labels, batch_size=256, verbose=1)\n    print(evaluationResult)<\/code><\/pre>\n\n\n\n
The training “loop” then itself calls this method like this:<\/p>\n\n\n\n
model = keras.models.Sequential([\n     normalizer,\n     # here goes the model definition.\n     layers.Dense(units=1)\n])\nrunTrainingAndMeasureTestAccuracy(model, 0.01)<\/code><\/pre>\n\n\n\n
Running a set of measurements, this results in the following data points:<\/p>\n\n\n\n
Learning Rate<\/td>Dense Layer 1<\/td>Dense Layer 2<\/td>Dense Layer 3<\/td>Dense Layer 4<\/td>Dense Layer 5<\/td>Dense Layer 6<\/td>Dense Layer 7<\/td>Dense Layer 8<\/td>Dense Layer 9<\/td>Epochs<\/td>Training Accuracy<\/td>Test Accuracy<\/td>Training Duration [s]<\/td>Avg Training Time\/Epoch<\/td><\/tr>
0,01<\/td>64<\/td>64<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>27<\/td>1<\/td>0,99994<\/td>41,5<\/td>1,54 s<\/td><\/tr>
0,01<\/td>64<\/td>64<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>18<\/td>1<\/td>1<\/td>28,5<\/td>1,58 s<\/td><\/tr>
0,01<\/td>64<\/td>64<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>15<\/td>1<\/td>1<\/td>23,3<\/td>1,55 s<\/td><\/tr>
0,01<\/td>32<\/td>32<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>34<\/td>1<\/td>0,9997<\/td>50,6<\/td>1,49 s<\/td><\/tr>
0,01<\/td>32<\/td>32<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9963<\/td>0,9957<\/td>77,7<\/td>1,55 s<\/td><\/tr>
0,01<\/td>32<\/td>32<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9934<\/td>0,9966<\/td>74,6<\/td>1,49 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>12<\/td>1<\/td>1<\/td>20,9<\/td>1,74 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>20<\/td>1<\/td>0,9999<\/td>41,4<\/td>2,07 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td>9<\/td>1<\/td>1<\/td>15<\/td>1,67 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>16<\/td>1<\/td>0,9999<\/td>22,7<\/td>1,42 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>38<\/td>0,9993<\/td>0,9993<\/td>51,8<\/td>1,36 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9998<\/td>0,9998<\/td>71,6<\/td>1,43 s<\/td><\/tr>
0,01<\/td>256<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9961<\/td>0,9969<\/td>69,8<\/td>1,40 s<\/td><\/tr>
0,01<\/td>256<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>44<\/td>1<\/td>0,9999<\/td>82,3<\/td>1,87 s<\/td><\/tr>
0,01<\/td>256<\/td>128<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>34<\/td>1<\/td>1<\/td>49<\/td>1,44 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td>64<\/td><\/td><\/td><\/td><\/td><\/td><\/td>13<\/td>1<\/td>0,9999<\/td>20,7<\/td>1,59 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td>64<\/td><\/td><\/td><\/td><\/td><\/td><\/td>11<\/td>1<\/td>1<\/td>17,7<\/td>1,61 s<\/td><\/tr>
0,01<\/td>128<\/td>128<\/td>64<\/td><\/td><\/td><\/td><\/td><\/td><\/td>16<\/td>1<\/td>1<\/td>26,1<\/td>1,63 s<\/td><\/tr>
0,01<\/td>384<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9503<\/td>0,9477<\/td>91,7<\/td>1,83 s<\/td><\/tr>
0,01<\/td>384<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9472<\/td>0,9458<\/td>108,2<\/td>2,16 s<\/td><\/tr>
0,01<\/td>384<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9417<\/td>0,9414<\/td>93,4<\/td>1,87 s<\/td><\/tr>
0,01<\/td>1024<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9506<\/td>0,9429<\/td>64,8<\/td>1,30 s<\/td><\/tr>
0,01<\/td>1024<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9556<\/td>0,9603<\/td>82,2<\/td>1,64 s<\/td><\/tr>
0,01<\/td>1024<\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td><\/td>50<\/td>0,9513<\/td>0,9554<\/td>65,9<\/td>1,32 s<\/td><\/tr>
0,01<\/td>32<\/td>32<\/td>32<\/td>32<\/td>32<\/td>32<\/td><\/td><\/td><\/td>40<\/td>0,9997<\/td>0,9998<\/td>80,4<\/td>2,01 s<\/td><\/tr>
0,01<\/td>32<\/td>32<\/td>32<\/td>32<\/td>32<\/td>32<\/td><\/td><\/td><\/td>23<\/td>1<\/td>1<\/td>45,6<\/td>1,98 s<\/td><\/tr>
0,01<\/td>32<\/td>32<\/td>32<\/td>32<\/td>32<\/td>32<\/td><\/td><\/td><\/td>30<\/td>1<\/td>1<\/td>59,1<\/td>1,97 s<\/td><\/tr>
0,01<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>50<\/td>0,9808<\/td>0,9591<\/td>133,5<\/td>2,67 s<\/td><\/tr>
0,01<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>50<\/td>0,9478<\/td>0,9506<\/td>137,3<\/td>2,75 s<\/td><\/tr>
0,01<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>16<\/td>47<\/td>0,9361<\/td>0,9417<\/td>118,6<\/td>2,52 s<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
It is to be admitted that this small series of measurement are way too small to allow concluding general statements, but the following hypothesizes may appear worthwhile having a closer look at:<\/p>\n\n\n\n