string formatting conversion to f-string via flynt

julrog · julrog · commit 27f3ae61021d · 2024-01-01T17:07:19.000+01:00
diff --git a/data/mnist_data_handler.py b/data/mnist_data_handler.py
@@ -113,8 +113,8 @@ def get_unbalance_data(main_class: int, other_class_percentage: float, class_sel
 
 def split_mnist_data(class_selection: Optional[List[int]] = None) -> None:
     (x_train, y_train), (x_test, y_test), input_shape, num_classes = get_basic_data()
-    logging.info('splitting %i train examples' % x_train.shape[0])
-    logging.info('splitting %i test examples' % x_test.shape[0])
+    logging.info(f'splitting {x_train.shape[0]} train examples')
+    logging.info(f'splitting {x_test.shape[0]} test examples')
 
     separated_train_data: List[Tuple[np.array, np.array]] = [([], []) for _ in
                                                              range(num_classes)]
@@ -171,24 +171,24 @@ def split_mnist_data(class_selection: Optional[List[int]] = None) -> None:
             )
 
     for i, class_id in enumerate(ensured_class_selection):
-        logging.info('%i train examples for class #%i' %
-                     (processed_separated_train_data[i][0].shape[0], class_id))
-        logging.info('%i test examples for class #%i' %
-                     (processed_separated_test_data[i][0].shape[0], class_id))
+        logging.info(
+            f'{processed_separated_train_data[i][0].shape[0]} train examples for class #{class_id}')
+        logging.info(
+            f'{processed_separated_test_data[i][0].shape[0]} test examples for class #{class_id}')
 
     data_path: str = DATA_PATH + 'mnist'
     if not os.path.exists(data_path):
         os.makedirs(data_path)
 
     if len(ensured_class_selection) == num_classes:
-        np.savez('%s/mnist_train_split' %
-                 data_path, processed_separated_train_data)
-        np.savez('%s/mnist_test_split' %
-                 data_path, processed_separated_test_data)
+        np.savez(f'{data_path}/mnist_train_split',
+                 processed_separated_train_data)
+        np.savez(f'{data_path}/mnist_test_split',
+                 processed_separated_test_data)
     else:
-        np.savez('%s/mnist_train_split_%s' % (data_path, ''.join(str(e) + '_' for e in ensured_class_selection)),
+        np.savez(f"{data_path}/mnist_train_split_{''.join(str(e) + '_' for e in ensured_class_selection)}",
                  processed_separated_train_data)
-        np.savez('%s/mnist_test_split_%s' % (data_path, ''.join(str(e) + '_' for e in ensured_class_selection)),
+        np.savez(f"{data_path}/mnist_test_split_{''.join(str(e) + '_' for e in ensured_class_selection)}",
                  processed_separated_test_data)
 
-    logging.info("saved split data to \"%s\"" % data_path)
+    logging.info(f"saved split data to \"{data_path}\"")
diff --git a/data/model_data.py b/data/model_data.py
@@ -106,4 +106,4 @@ def check_model_supported_layer(self) -> None:
         for index, layer in enumerate(self.model.layers):
             if layer.__class__.__name__ not in SUPPORTED_LAYER and layer.__class__.__name__ not in IGNORED_LAYER:
                 raise Exception(
-                    "'%s' layer type of model not supported!" % layer.__class__.__name__)
+                    f"'{layer.__class__.__name__}' layer type of model not supported!")
diff --git a/evaluation/create_plot.py b/evaluation/create_plot.py
@@ -31,9 +31,9 @@ def save_plot(name: str) -> None:
         BASE_PATH, os.path.join('storage', 'evaluation'))
     if not os.path.exists(directory_path):
         os.makedirs(directory_path)
-    file_path: str = '%s/%s.svg' % (directory_path, name)
+    file_path: str = f'{directory_path}/{name}.svg'
     plt.savefig(file_path)
-    file_path = '%s/%s.jpg' % (directory_path, name)
+    file_path = f'{directory_path}/{name}.jpg'
     plt.savefig(file_path)
 
 
@@ -65,7 +65,7 @@ def create_importance_plot(filename: str, importance_name: str, timed_name: bool
     plot.axvline(x=90, color='red')
     trans = transforms.blended_transform_factory(
         plot.get_yticklabels()[0].get_transform(), plot.transData)
-    plot.text(0.9, -0.025, '{:.0f}'.format(90), color='red', transform=trans,
+    plot.text(0.9, -0.025, f'{90:.0f}', color='red', transform=trans,
               va='bottom', ha='center')
 
     save_plot(importance_name)
@@ -106,10 +106,10 @@ def create_importance_plot_compare_regularizer(filename: str, importance_names:
     plot.axvline(x=90, color='red')
     trans = transforms.blended_transform_factory(
         plot.get_yticklabels()[0].get_transform(), plot.transData)
-    plot.text(0.9, -0.025, '{:.0f}'.format(90), color='red', transform=trans,
+    plot.text(0.9, -0.025, f'{90:.0f}', color='red', transform=trans,
               va='bottom', ha='center')
 
-    save_plot('regularizer_compare_%s' % check_importance_type)
+    save_plot(f'regularizer_compare_{check_importance_type}')
 
     if show:
         plt.show()
@@ -144,7 +144,7 @@ def create_importance_plot_compare_bn_parameter(filename: str, importance_names:
     for line in plot.lines:
         plt.setp(line, linewidth=3, alpha=0.6)
 
-    save_plot('bn_parameter_compare_%s' % check_importance_type)
+    save_plot(f'bn_parameter_compare_{check_importance_type}')
 
     if show:
         plt.show()
@@ -157,10 +157,9 @@ def create_importance_plot_compare_class_vs_all(filename: str, importance_name:
                                                 show: bool = False) -> None:
     converted_data: List[List[Any]] = []
 
-    importance_data_name: str = '%s_[%s]' % (
-        check_importance_type, class_index) if class_specific_data else check_importance_type
+    importance_data_name: str = f'{check_importance_type}_[{class_index}]' if class_specific_data else check_importance_type
     overall_importance_label_name: str = 'all_classes'
-    class_importance_label_name: str = 'class_[%s]' % class_index
+    class_importance_label_name: str = f'class_[{class_index}]'
     data: Dict[Any, Any] = load_data(filename, importance_name, timed_name)
 
     for percent, percent_data in data.items():
@@ -181,8 +180,8 @@ def create_importance_plot_compare_class_vs_all(filename: str, importance_name:
     plot: Axes = df.plot(legend=True)
     plot.set_ylabel('Prediction Accuracy')
 
-    save_plot('%s_class_compare_%s_%i' %
-              (importance_name, check_importance_type, class_index))
+    save_plot(
+        f'{importance_name}_class_compare_{check_importance_type}_{class_index}')
 
     if show:
         plt.show()
@@ -195,9 +194,8 @@ def create_importance_plot_compare_classes_vs_all(filename: str, importance_name
     converted_data: List[List[Any]] = []
 
     for i in range(10):
-        importance_data_name: str = '%s_[%s]' % (
-            check_importance_type, i) if class_specific_data else check_importance_type
-        class_importance_label_name: str = "Digit \"%s\"" % i
+        importance_data_name: str = f'{check_importance_type}_[{i}]' if class_specific_data else check_importance_type
+        class_importance_label_name: str = f"Digit \"{i}\""
         data: Dict[Any, Any] = load_data(filename, importance_name, timed_name)
 
         for percent, percent_data in data.items():
@@ -223,7 +221,7 @@ def create_importance_plot_compare_classes_vs_all(filename: str, importance_name
     for line in plot.lines:
         plt.setp(line, linewidth=3, alpha=0.7)
 
-    save_plot('%s_class_compare_%s' % (importance_name, check_importance_type))
+    save_plot(f'{importance_name}_class_compare_{check_importance_type}')
 
     if show:
         plt.show()
diff --git a/evaluation/evaluator.py b/evaluation/evaluator.py
@@ -100,7 +100,7 @@ def prune_model(self,
             self.importance_calculation.name,
             data)
 
-        logging.info('Pruned edges: %i' % pruned_edges)
+        logging.info(f'Pruned edges: {pruned_edges}')
 
     def accuracy_report(self, truths: np.array, predictions: np.array) -> Dict[str, Any]:
         accuracy_report: Dict[str, Any] = dict()
@@ -136,10 +136,10 @@ def test_model(self, importance_prune_percent: str) -> None:
         test_score = self.model_data.model.evaluate(
             self.x_test, self.y_test, verbose=0)
 
-        logging.info('Train loss: %f, Train accuracy: %f' %
-                     (train_score[0], train_score[1]))
-        logging.info('Test loss: %f, Test accuracy: %f' %
-                     (test_score[0], test_score[1]))
+        logging.info(
+            f'Train loss: {train_score[0]:f}, Train accuracy: {train_score[1]:f}')
+        logging.info(
+            f'Test loss: {test_score[0]:f}, Test accuracy: {test_score[1]:f}')
 
         truth_train: np.array = np.argmax(self.y_train, axis=1)
         predict_train: np.array = self.model_data.model.predict(self.x_train)
diff --git a/examples/create_images.py b/examples/create_images.py
@@ -79,7 +79,7 @@ def plot_histogram(path: str) -> None:
         pdf = KernelDensity(kernel='epanechnikov', bandwidth=bandwidth).fit(
             z_values).score_samples(x_grid[:, None])
         ax.plot(x_grid, np.exp(pdf), linewidth=2, alpha=0.6,
-                label='bandwidth=%.2f' % bandwidth)
+                label=f'bandwidth={bandwidth:.2f}')
 
     ax.hist(z_values, slots, facecolor='gray',
             histtype='stepfilled', alpha=0.4, density=True)
diff --git a/examples/evaluation_plots.py b/examples/evaluation_plots.py
@@ -28,8 +28,8 @@
 
 def create_importance_data(model_data: ModelData, importance_type: ImportanceType) -> None:
     pn = ProcessedNetwork(model_data=model_data)
-    pn.generate_importance_data('mnist/mnist_train_split%s' % split_suffix,
-                                'mnist/mnist_test_split%s' % split_suffix,
+    pn.generate_importance_data(f'mnist/mnist_train_split{split_suffix}',
+                                f'mnist/mnist_test_split{split_suffix}',
                                 importance_type)
     model_data.store_model_data()
     model_data.save_data()
@@ -56,8 +56,8 @@ def evaluate_importance(model_data: ModelData, importance_type: ImportanceType,
 model_data: ModelData = create(
     name=name, batch_size=128, epochs=15, layer_data=layer_data, regularized=False)
 split_suffix: str = ''
-if not os.path.exists('%smnist/mnist_train_split%s' % (DATA_PATH, split_suffix)) or not os.path.exists(
-        '%smnist/mnist_test_split' % DATA_PATH):
+if not os.path.exists(f'{DATA_PATH}mnist/mnist_train_split{split_suffix}') or not os.path.exists(
+        f'{DATA_PATH}mnist/mnist_test_split'):
     split_mnist_data()
 
 importance_types: List[ImportanceType] = [
diff --git a/examples/process_mnist_model.py b/examples/process_mnist_model.py
@@ -33,13 +33,13 @@
 split_suffix: str = ''
 if class_selection is not None:
     ('_' + ''.join(str(e) + '_' for e in class_selection))
-if not os.path.exists('%smnist/mnist_train_split%s' % (DATA_PATH, split_suffix)) or not os.path.exists(
-        '%smnist/mnist_test_split' % DATA_PATH):
+if not os.path.exists(f'{DATA_PATH}mnist/mnist_train_split{split_suffix}') or not os.path.exists(
+        f'{DATA_PATH}mnist/mnist_test_split'):
     split_mnist_data(class_selection)
 
 pn = ProcessedNetwork(model_data=basic_model_data)
-pn.generate_importance_data('mnist/mnist_train_split%s' % split_suffix,
-                            'mnist/mnist_test_split%s' % split_suffix,
+pn.generate_importance_data(f'mnist/mnist_train_split{split_suffix}',
+                            f'mnist/mnist_test_split{split_suffix}',
                             importance_type)
 basic_model_data.store_model_data()
 basic_model_data.save_data()
diff --git a/gui/ui_window.py b/gui/ui_window.py
@@ -44,7 +44,7 @@ def __init__(self) -> None:
 
         self.gui_root.protocol('WM_DELETE_WINDOW', self.on_closing)
         self.gui_root.geometry(
-            '+%d+%d' % (self.window_config['screen_x'], self.window_config['screen_y']))
+            f"+{self.window_config['screen_x']}+{self.window_config['screen_y']}")
         self.gui_root.bind('<Configure>', self.handle_configure)
 
     def start(self, layer_data: Optional[List[int]] = None) -> None:
diff --git a/neural_network_preprocessing/create_mnist_model.py b/neural_network_preprocessing/create_mnist_model.py
@@ -46,7 +46,7 @@ def create(name: str, batch_size: int, epochs: int, layer_data: List[int], learn
            regularized: bool = False, train_type: ModelTrainType = ModelTrainType.BALANCED, main_class: Optional[int] = None,
            other_class_percentage: Optional[float] = None, class_selection: Optional[List[int]] = None) -> ModelData:
     logging.info(
-        "Create MNIST neural network model with training type \"%s\"." % train_type.name)
+        f"Create MNIST neural network model with training type \"{train_type.name}\".")
 
     if train_type is not ModelTrainType.UNBALANCED:
         (x_train, y_train), (x_test,
@@ -61,8 +61,8 @@ def create(name: str, batch_size: int, epochs: int, layer_data: List[int], learn
         (x_train, y_train), (x_test, y_test), input_shape, num_classes = get_unbalance_data(main_class,
                                                                                             other_class_percentage,
                                                                                             class_selection)
-    logging.info('Train examples: %i' % x_train.shape[0])
-    logging.info('Test examples: %i' % x_test.shape[0])
+    logging.info(f'Train examples: {x_train.shape[0]}')
+    logging.info(f'Test examples: {x_test.shape[0]}')
 
     if class_selection is not None:
         num_classes = len(class_selection)
@@ -93,8 +93,8 @@ def evaluate_model(model_data: ModelData, x_train: Any, y_train: Any, x_test: An
         -> ModelData:
     train_score = model_data.model.evaluate(x_train, y_train, verbose=0)
     test_score = model_data.model.evaluate(x_test, y_test, verbose=0)
-    logging.info('Train loss: %f, Train accuracy: %f, Test loss: %f, Test accuracy: %f' % (
-        train_score[0], train_score[1], test_score[0], test_score[1]))
+    logging.info(
+        f'Train loss: {train_score[0]:f}, Train accuracy: {train_score[1]:f}, Test loss: {test_score[0]:f}, Test accuracy: {test_score[1]:f}')
 
     c_y_test = np.argmax(y_test, axis=1)
 
@@ -111,8 +111,8 @@ def evaluate_model(model_data: ModelData, x_train: Any, y_train: Any, x_test: An
 def calculate_performance_of_model(model_data: ModelData) -> ModelData:
     (x_train, y_train), (x_test, y_test), input_shape, num_classes = get_prepared_data()
 
-    logging.info('Train examples: %i' % x_train.shape[0])
-    logging.info('Test examples: %i' % x_test.shape[0])
+    logging.info(f'Train examples: {x_train.shape[0]}')
+    logging.info(f'Test examples: {x_test.shape[0]}')
 
     model_data.reload_model()
     model_data.model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(0.001),
diff --git a/neural_network_preprocessing/neural_network.py b/neural_network_preprocessing/neural_network.py
@@ -67,8 +67,8 @@ def get_fine_tuned_model_data(self, class_index: int, train_data: Tuple[np.array
 
         train_score = modified_model.evaluate(x_train, y_train, verbose=0)
         test_score = modified_model.evaluate(x_test, y_test, verbose=0)
-        logging.info('Class %i: Train loss: %f, Train accuracy: %f, Test loss: %f, Test accuracy: %f' % (
-            class_index, train_score[0], train_score[1], test_score[0], test_score[1]))
+        logging.info(
+            f'Class {class_index}: Train loss: {train_score[0]:f}, Train accuracy: {train_score[1]:f}, Test loss: {test_score[0]:f}, Test accuracy: {test_score[1]:f}')
 
         c_y_test = np.argmax(y_test, axis=1)
         prediction_test = np.argmax(modified_model.predict(x_test), axis=1)
@@ -84,7 +84,7 @@ def get_fine_tuned_model_data(self, class_index: int, train_data: Tuple[np.array
         fine_tuned_data['test_accuracy'] = str(test_score[1])
         fine_tuned_data['classification_report'] = c_report
 
-        self.model_data.store_data('modified_fine_tuned_performance', self.name, 'class_%i' % class_index,
+        self.model_data.store_data('modified_fine_tuned_performance', self.name, f'class_{class_index}',
                                    fine_tuned_data)
 
         return modified_model
@@ -109,17 +109,17 @@ def extract_importance_from_model(self, original_model: Model, fine_tuned_model:
     def generate_importance_for_data(self, train_data_path: str, test_data_path: str) -> Tuple[List[np.array],
                                                                                                List[np.array]]:
         raw_train_data: dict = np.load(
-            '%s/%s.npz' % (DATA_PATH, train_data_path), allow_pickle=True)
+            f'{DATA_PATH}/{train_data_path}.npz', allow_pickle=True)
         train_data: List[np.array] = raw_train_data['arr_0']
 
         raw_test_data: dict = np.load(
-            '%s/%s.npz' % (DATA_PATH, test_data_path), allow_pickle=True)
+            f'{DATA_PATH}/{test_data_path}.npz', allow_pickle=True)
         test_data: List[np.array] = raw_test_data['arr_0']
 
         if (len(train_data) is not self.num_classes and self.num_classes is not None) or (
                 len(test_data) is not self.num_classes and self.num_classes is not None):
             raise Exception(
-                'Data does not match number of classes %i.' % self.num_classes)
+                f'Data does not match number of classes {self.num_classes}.')
 
         for i, (class_test_data, class_train_data) in enumerate(zip(test_data, train_data)):
             fine_tuned_model = self.get_fine_tuned_model_data(
@@ -160,8 +160,8 @@ def generate_importance_data(self, train_data_path: str, test_data_path: str,
                         max_node_importance = node_class_importance
             normalized_node_importance_data.append(
                 normalized_layer_importance / max_node_importance)
-            logging.info('Node importance - Min: %f, Max: %f' %
-                         (min_node_importance, max_node_importance))
+            logging.info(
+                f'Node importance - Min: {min_node_importance:f}, Max: {max_node_importance:f}')
         node_importance_data = normalized_node_importance_data
 
         normalized_edge_importance_data: List[np.array] = []
@@ -179,8 +179,8 @@ def generate_importance_data(self, train_data_path: str, test_data_path: str,
                     min_edge_importance = current_edge_min
                 absolute_layer_data /= max_edge_importance
                 new_layer_data.append(absolute_layer_data)
-            logging.info('Edge importance - Min: %f, Max: %f' %
-                         (min_edge_importance, max_edge_importance))
+            logging.info(
+                f'Edge importance - Min: {min_edge_importance:f}, Max: {max_edge_importance:f}')
             normalized_edge_importance_data.append(
                 np.stack(new_layer_data, axis=0))
         edge_importance_data = normalized_edge_importance_data
diff --git a/opengl_helper/buffer.py b/opengl_helper/buffer.py
@@ -54,8 +54,8 @@ def load(self, data: Any) -> None:
         self.size = data.nbytes
         if self.ssbo:
             if data.nbytes > self.max_ssbo_size:
-                raise Exception('Data to big for SSBO (%d bytes, max %d bytes).' % (
-                    data.nbytes, self.max_ssbo_size))
+                raise Exception(
+                    f'Data to big for SSBO ({data.nbytes} bytes, max {self.max_ssbo_size} bytes).')
 
             glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.handle)
             glBufferData(GL_SHADER_STORAGE_BUFFER,
@@ -185,7 +185,7 @@ def load_empty(self, dtype: Any, size: int, component_size: int) -> None:
             empty = np.zeros(int(self.max_ssbo_size / 4), dtype=dtype)
             buffer_count = math.ceil(
                 int(size / component_size) / int(self.max_ssbo_size / (component_size * self.object_size * 4)))
-            logging.info('Data split into %i buffer' % buffer_count)
+            logging.info(f'Data split into {buffer_count} buffer')
             for i in range(buffer_count):
                 if i >= len(self.handle):
                     self.handle.append(glGenBuffers(1))
diff --git a/opengl_helper/shader.py b/opengl_helper/shader.py
@@ -42,7 +42,7 @@ def uniform_func_3iv(location: int, data: List[int]) -> None:
 
         return uniform_func_3iv
     raise Exception(
-        "Uniform setter function for '%s' not defined." % uniform_setter)
+        f"Uniform setter function for '{uniform_setter}' not defined.")
 
 
 class ShaderSetting:
diff --git a/opengl_helper/texture.py b/opengl_helper/texture.py
@@ -90,5 +90,5 @@ def __init__(self) -> None:
     def activate(self, position: int) -> None:
         if position < 0 or position > self.max_textures:
             raise Exception(
-                "OGL Texture position '%d' not available." % position)
+                f"OGL Texture position '{position}' not available.")
         glActiveTexture(GL_TEXTURE0 + position)
diff --git a/processing/network_processing.py b/processing/network_processing.py
diff --git a/processing/processing_handler.py b/processing/processing_handler.py
diff --git a/start_tool.py b/start_tool.py
diff --git a/start_tool_vr.py b/start_tool_vr.py
diff --git a/utility/file.py b/utility/file.py
diff --git a/utility/log_handling.py b/utility/log_handling.py
