GCI108 PreferAppendLeft fix: change rule number (97->108), resolve conflicts

Co-authored-by: DataLabGroupe-CreditAgricole <[email protected]>

Author: cleophass

CHANGELOG.md

@@ -9,13 +9,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Add rule GCI 97 Prefer Append Left
+- [#381](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/381) Add rule GCI 108 Prefer Append Left
 - [#400](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/400) Add rule GCI535 - Prefer usage of Intl.NumberFormat
 
 ### Changed
 
 ### Deleted
 
+## [2.4.0] - 2025-07-20
+
+### Added
+
+- [#390](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/390) Added rule GCI106 : Detect scalar sqrt usage in loops and suggest vectorized alternatives
+- [#389](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/389) Add rule GCI105, Add a rule on Python String Concatenation
+- [#388](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/388) Added rule GCI104 on Torch Tensor types
+- [#387](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/387) Add rule GCI103, add specifications for a new rule on iteration method for dict in Python
+- [#386](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/386) Add rule GCI102, recommending the use of pinned memory for the dataloader when transferring data from the CPU to the GPU.
+- [#385](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/385) Add rule GCI101, Added documentation for the rule : disables bias in convolutional layers preceding Batch Normalization.
+- [#384](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/384) Add specifications for rule GCI100, this rule is specific to Python because it's based on the `PyTorch` library, a library used for Deep Learning.
+- [#379](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/379) Add rule GCI99 Avoid CSV Format, this rule is designed for Python but it can be implemented in other languages. The rule suggests using more efficient formats like Feather or Parquet instead of CSV.
+- [#401](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/401) Add rule GCI98 for Java. Don't catch RuntimeException. They represent a problem in the program that should be fixed, not handled
+
+## [2.3.0] - 2025-07-08
+
+### Added
+
+- [#400](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/400) Add rule GCI535 - Prefer usage of Intl.NumberFormat
+- [#382](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/382) Add specifications for rule GCI96, this rule is specific to Python because it's based on the `pandas` library, a library used for data.
+- [#383](https://github.com/green-code-initiative/creedengo-rules-specifications/pull/383) Add specifications for rule GCI97, this rule concerns the different ways of squaring a value.
+
+### Deleted
+
 - [#58](https://github.com/green-code-initiative/creedengo-php/issues/58) Deprecation of GCI66 rule for PHP
 - deletion of deprecated PHP GCI34 rule
 
@@ -420,7 +444,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Comparison List
 
-[unreleased](https://github.com/green-code-initiative/creedengo-rules-specifications/compare/2.2.3...HEAD)
+[unreleased](https://github.com/green-code-initiative/creedengo-rules-specifications/compare/2.4.0...HEAD)
+[2.4.0](https://github.com/green-code-initiative/creedengo-rules-specifications/compare/2.3.0...2.4.0)
+[2.3.0](https://github.com/green-code-initiative/creedengo-rules-specifications/compare/2.2.3...2.3.0)
 [2.2.3](https://github.com/green-code-initiative/creedengo-rules-specifications/compare/2.2.2...2.2.3)
 [2.2.2](https://github.com/green-code-initiative/creedengo-rules-specifications/compare/2.2.1...2.2.2)
 [2.2.1](https://github.com/green-code-initiative/creedengo-rules-specifications/compare/2.2.0...2.2.1)

RULES.md

@@ -0,0 +1,18 @@
+{
+  "title": "DATA/AI PyTorch - Wrap PyTorch Inference in `torch.no_grad()`",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant/Issue",
+    "constantCost": "10min"
+  },
+  "tags": [
+    "creedengo",
+    "eco-design",
+    "performance",
+    "memory",
+    "ai",
+    "PyTorch"
+  ],
+  "defaultSeverity": "Minor"
+}

src/main/rules/GCI100/GCI100.json

@@ -0,0 +1,73 @@
+This rule is specific to Python because it's related to PyTorch library, which is widely used for deep learning and machine learning tasks in Python.
+
+Using a PyTorch model in evaluation mode without wrapping inference in `torch.no_grad()` leads to unnecessary gradient tracking, which increases memory usage and energy consumption. This rule applies specifically to PyTorch, but aligns with general energy efficiency and eco-design principles: avoid performing unnecessary computations.
+
+== Non Compliant Code Example
+
+[source,python]
+----
+model.eval()
+for inputs in dataloader:
+    outputs = model(inputs)
+----
+
+In this case, PyTorch still tracks gradients even though no backward pass is needed.
+
+== Compliant Solution
+
+[source,python]
+----
+model.eval()
+with torch.no_grad():
+    for inputs in dataloader:
+        outputs = model(inputs)
+----
+
+Using `torch.no_grad()` disables gradient computation during inference, saving memory and computational resources.
+
+== Relevance Analysis
+
+Local experiments were conducted to assess the carbon emissions associated with inference with and without `torch.no_grad()`.
+
+=== Configuration
+
+* Processor: Intel(R) Core(TM) Ultra 5 135U, 2100 MHz, 12 cores, 14 logical processors
+* RAM: 16 GB
+* CO₂ Emissions Measurement: https://mlco2.github.io/codecarbon/[CodeCarbon]
+* Framework: PyTorch 2.1
+
+=== Context
+
+We benchmarked inference using a small convolutional neural network on batches of random tensors. Two configurations were compared:
+* Inference with gradient tracking (default)
+* Inference using `torch.no_grad()`
+
+=== Impact Analysis
+
+We begin by analyzing RAM and GPU memory usage. The graph below shows the memory consumption during inference, with and without torch.no_grad():
+
+image::memory.png[]
+
+As expected, using torch.no_grad() significantly reduces memory usage. This effect is especially noticeable on GPU, since it no longer needs to store intermediate values required for gradient computation.
+
+The blue shaded area represents the range of memory or emissions observed across multiple batch iterations during a single epoch.
+
+Next, we compare the carbon emissions generated in both cases:
+
+image::emissions.png[]
+
+While the difference in emissions is less dramatic than for memory usage, it remains meaningful. This is because most of the energy consumption comes from matrix operations, which are computationally expensive — and torch.no_grad() helps avoid some unnecessary overhead.
+
+== Conclusion
+
+The rule is relevant. Wrapping inference in `torch.no_grad()`:
+- Reduces energy consumption
+- Improves inference performance
+- Prevents memory waste
+
+This practice is essential in any production or evaluation setting involving PyTorch models.
+
+== References
+
+* https://pytorch.org/docs/stable/generated/torch.no_grad.html
+

src/main/rules/GCI100/python/GCI100.asciidoc

@@ -0,0 +1,18 @@
+{
+  "title": "AI Disable bias in convolutional layers when it's followed by a batch norm layer",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant/Issue",
+    "constantCost": "10min"
+  },
+  "tags": [
+    "creedengo",
+    "eco-design",
+    "performance",
+    "memory",
+    "ai",
+    "convolutional"
+  ],
+  "defaultSeverity": "Minor"
+}

src/main/rules/GCI100/python/emissions.png

@@ -0,0 +1,82 @@
+This rule is specific to Deep Learning architectures built with convolutional layers followed by Batch Normalization.
+
+Using a bias term in a convolutional layer that is immediately followed by a Batch Normalization (BatchNorm) layer is redundant and unnecessary. In such cases, the bias added by the convolution is effectively canceled out during the normalization process, as BatchNorm subtracts the mean and applies its own learnable affine transformation. As a result, the bias from the convolutional layer has no practical effect on the model's output. Removing it reduces the number of parameters—improving model efficiency slightly in terms of memory usage and emissions—while maintaining or even slightly improving training accuracy.
+
+== Non Compliant Code Example
+
+[source,python]
+----
+nn.Sequential(
+    nn.Conv2d(in_channels, out_channels, kernel_size, bias=True),
+    nn.BatchNorm2d(out_channels),
+    nn.ReLU()
+)
+----
+
+In this example, a convolutional layer includes a bias term, which is unnecessary when immediately followed by a BatchNorm layer.
+
+== Compliant Solution
+
+[source,python]
+----
+nn.Sequential(
+    nn.Conv2d(in_channels, out_channels, kernel_size, bias=False),
+    nn.BatchNorm2d(out_channels),
+    nn.ReLU()
+)
+----
+
+Since `BatchNorm2d` normalizes and shifts the output using learnable parameters, the bias from the preceding convolution becomes redundant.
+
+== Relevance Analysis
+
+Local experiments were conducted to assess the impact of disabling bias in convolutional layers followed by BatchNorm.
+
+=== Configuration
+
+* Processor: Intel(R) Xeon(R) CPU 3.80GHz
+* RAM: 64GB
+* GPU: NVIDIA Quadro RTX 6000
+* CO₂ Emissions Measurement: https://mlco2.github.io/codecarbon/[CodeCarbon]  
+* Framework: PyTorch 
+
+=== Context
+
+Two models were trained under identical settings:
+- One with `bias=True` in convolutional layers preceding BatchNorm
+- One with `bias=False`
+
+The following metrics were compared:
+- Training time per epoch
+- GPU memory usage
+- Parameter count
+- Training and test accuracy
+- CO₂ emissions per epoch
+
+=== Impact Analysis
+
+image::convresult.png[]
+
+- **Training Time:** Nearly identical (~30 seconds/epoch) between configurations.
+- **Memory Usage:** lower for the "Without Bias" model in terms of reserved GPU memory.
+- **Training Accuracy:** We can see that there's no significant difference in training accuracy between the two models, with both converging to similar values.
+- **Test Accuracy:** Final accuracy remained the same for both models, confirming no negative impact.
+- **Parameter Count:**  
+  - With Bias: 155,850  
+  - Without Bias: 155,626  
+  This shows a real reduction in parameters.
+- **Emissions:** Emissions per epoch were fractionally lower without bias, due to a leaner architecture and reduced operations.
+
+== Conclusion
+
+Disabling bias in convolutional layers followed by BatchNorm:
+
+- Reduces the parameter count
+- Optimizes memory and emissions
+- Maintains accuracy
+
+== References
+
+Credit : https://github.com/AghilesAzzoug/GreenPyData
+- https://arxiv.org/pdf/1502.03167
+- https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html

src/main/rules/GCI100/python/memory.png

@@ -0,0 +1,18 @@
+{
+  "title": "AI Use pinned memory on DataLoader when using GPU",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant/Issue",
+    "constantCost": "10min"
+  },
+  "tags": [
+    "creedengo",
+    "eco-design",
+    "performance",
+    "memory",
+    "ai",
+    "pytorch"
+  ],
+  "defaultSeverity": "Minor"
+}