Docs

Author: n-shevko

docs/source/guide/guide_part_i.rst

@@ -375,3 +375,53 @@ their simulation separately at the temporal granularity of chosen :code:`dt`, in
 This is a strict departure from the computation of *deep neural networks* (DNNs), in which an ordering of layers is
 supposed, and layers' activations are computed *in sequence* from the shallowest to the deepest layer in a single time
 step, with the exclusion of recurrent layers, whose computations are still ordered in time.
+
+
+Lowering precision
+------------------
+
+You can choose the precision for the weights.
+It can be specified as the :code:`value_dtype` parameter of the Weight class.
+
+.. code-block:: python
+
+    MulticompartmentConnection(
+        ...
+        pipeline=[
+            Weight(
+                'weight',
+                w,
+                value_dtype='float16',
+                ...
+            )
+        ]
+    )
+
+Below is the performance statistics for float16 and float32.
+
+The data was obtained by running examples/benchmark/lowering_precision.py
+
+
+.. code-block:: text
+
+    precision: float32
+    Time (sec) | GPU memory (Mb)
+    19.7812    | 52
+    19.4812    | 52
+    19.0769    | 52
+    19.1530    | 52
+    Average time: 19.373075
+    Average memory: 52.0
+
+    precision: float16
+    Time (sec) | GPU memory (Mb)
+    19.5023    | 49
+    20.5734    | 49
+    19.8735    | 49
+    19.8931    | 49
+    Average time: 19.960575
+    Average memory: 49.0
+
+
+As you can see, reducing from float32 to float16 does not provide a significant advantage in terms of time or memory.
+The float16 option only reduces memory usage by 6%.

examples/benchmark/lowering_precision.py

@@ -0,0 +1,49 @@
+import re
+import os
+import subprocess
+from statistics import mean
+
+precision_sample_size = 4
+precisions = ['float16', 'float32']
+
+folder = os.path.dirname(os.path.dirname(__file__))
+script = os.path.join(folder, 'mnist', 'batch_eth_mnist.py')
+data = {}
+for precision in precisions:
+    for _ in range(precision_sample_size):
+        result = subprocess.run(
+            f"python {script} --n_train 100 --batch_size 50 --n_test 10 --n_updates 1 --w_dtype {precision}",
+            shell=True, capture_output=True, text=True
+        )
+        output = result.stdout
+        time_match = re.search(r'Progress: 1 / 1 \((\d+\.\d+) seconds\)', output)
+        memory_match = re.search(r'Memory consumption: (\d+)mb', output)
+        data.setdefault(precision, []).append([
+            time_match.groups()[0],
+            memory_match.groups()[0]
+        ])
+        print("+")
+
+
+def print_table(data):
+    column_widths = [max(len(str(item)) for item in col) for col in zip(*data)]
+    for row in data:
+        formatted_row = " | ".join(f"{str(item):<{column_widths[i]}}" for i, item in enumerate(row))
+        print(formatted_row)
+
+
+average_time = {}
+average_memory = {}
+for precision, rows in data.items():
+    print(f"precision: {precision}")
+    table = [
+        ['Time (sec)', 'GPU memory (Mb)']
+    ] + rows
+    avg_time = mean(map(lambda i: float(i[0]), rows))
+    avg_memory = mean(map(lambda i: float(i[1]), rows))
+    print_table(table)
+    print(f"Average time: {avg_time}")
+    print(f"Average memory: {avg_memory}")
+    average_memory[precision] = avg_memory
+    average_time[precision] = avg_time
+    print('')

examples/mnist/batch_eth_mnist.py

@@ -384,6 +384,7 @@
 
 print("\nAll activity accuracy: %.2f" % (accuracy["all"] / n_test))
 print("Proportion weighting accuracy: %.2f \n" % (accuracy["proportion"] / n_test))
+print(f"Memory consumption: {round(torch.cuda.max_memory_allocated(device=None) / 1024 ** 2)}mb")
 
 print("Progress: %d / %d (%.4f seconds)" % (epoch + 1, n_epochs, t() - start))
 print("\nTesting complete.\n")