Can AI and the environment coexist?

At a time when digital technology is having an ever-increasing impact on the environment, it’s important to have a closer look at this issue. On July 2, 2024, Arcep reported that digital technology currently accounts for 3-4% of global greenhouse gas emissions and is set to grow strongly (+60% by 2040). It’s no news that we urgently need to rethink our approach and our use of digital technology. Except that, beyond the impact of digital technology, another element that is only growing is the use of AI-based systems.

• According to the European Parliament’s definition, AI is any tool, software, or machine designed to “reproduce human-related behaviors, such as reasoning, planning and creativity”.
• According to Afnor, an AI-based system consists of an algorithm, data, and the hardware needed to run it.

AI-based systems can be used for machine learning, image analysis and classification, text analysis… Reliable statistics on the number and growth of AI-based systems are hard to come by, but let’s take an example that will appeal to most people: OpenAI’s ChatGPT.

ChatGPT was launched in November 2022 by OpenAI, and in just two months it has absorbed more than 100 million active users. By the end of 2023, this number had reached 180 million. Several studies have focused on the environmental impact of AI, which no longer needs to be demonstrated.  This is quite logical, because, as Afnor tells us, we need to take into account everything that enables these algorithms to be executed. All this seems very immaterial, and it’s hard to imagine the resources that are required when a request is made to ChatGPT, yet given this impact, it’s urgent. This brings us to two new Afnor definitions:

“Efficient AI system: a system whose operation takes into account optimization mechanisms known from the state of the art to reduce its material and energy resource requirements and associated emissions, while maintaining sufficient performance”.

 

“AI frugal system: a system for which the need to use an AI system rather than another less consumptive solution to achieve the same objective has been demonstrated, best practices are adopted […] to reduce the environmental impact of the service using an AI algorithm, uses, and needs aim to stay within planetary limits […]”.

At a time when we’re using AI-based systems as if we were putting on our socks, it’s important to question the need for these kinds of algorithms. As a founder, how many colleagues have told me that they use AI to get the buzzword they need to get funding?

What we preach at WedoLow, then, is to question the nature of the algorithm that solves the problem at hand: perhaps another type of algorithm can perform just as well, while having a reduced impact on the resources needed to execute it. This question is very similar to writing specifications as part of an eco-design approach: it’s essential to define, before any development, the quality of service required when the application is released, to avoid using a bazooka to kill a fly. We’ll come back to this subject shortly.

If we now look at the definition of an efficient AI system, are any of these famous optimization mechanisms known to the state of the art? In fact, research in this area is very active, but some work has already been completed and used in industrial applications. Let’s take three examples:

One of the first things to consider when exploring the optimization mechanisms of AI algorithms is simplification. To that end, we’ll mention two of the existing techniques. In this way, data arithmetic can be optimized. For the rest of this article, let’s take the particular example of the “deep learning” AI system.

These algorithms are extremely resilient to errors caused by changes in data arithmetic, allowing integer rather than floating-point arithmetic and logic units to be used, reducing both execution time and power consumption. On this point, many topics already exist and are greatly facilitated by existing tools, we talk about quantification.

However, this topic requires, a very good knowledge of the quality requirements at the output of the considered application. Let’s take a well-known example, SqueezeNet^[1]. Its job? Give it an image as input and it tells you what it is: a cat, a dog, the WedoLow logo… It classifies images. Its quality metric is therefore the percentage of correct classification: does the network get it wrong 1% of the time? 0.01% of the time? What value is acceptable? This is the first thing you need to define before you can “prune” the data! Different types of arithmetic are then possible: fixed point, or custom-size floating point^[2].

This analysis of data arithmetic can also be carried out in conjunction with pruning. In the same way that we use quantization to try to keep the data sizes and arithmetic types relevant to our quality needs, pruning allows us to remove parameters from a network that have a very small impact on its quality in order to reduce its size (some deep neural networks can have up to several hundred billion parameters^[3]).

In fact, neural networks generally have only a subset of parameters that are essential to their operation. The weights are mostly the parameters that are pruned, and this work can be done at different times in the life of the network (e.g., during or after training). The two optimization techniques mentioned above are particularly useful when working on networks that need to run on reduced resources (e.g. embedded), as they help to reduce complexity.

An interesting approach to implementing artificial intelligence on a constrained system (for example, in the embedded domain) is to look at Tangled Program Graphs (TPGs)^[4]. The goal is to change the paradigm and use a lightweight model by construction (the TPG) based on the principles of genetic programming and “reinforcement learning”, i.e. the “trial and error” learning method (the computer is rewarded or punished). The TPG consists of three elements:

• programs (sequence of arithmetic instructions to take an input state and generate a real number)
• teams
• actions

These three elements make up the graph, where programs are the edges of the graph, teams are the internal nodes, and actions are the leaves of the graph. TPGs achieve state-of-the-art results while requiring one to three orders of magnitude less computation and two to ten orders of magnitude less memory to store the inference model^[5]. To increase their efficiency, they can be implemented using a high-performance language such as C++ and parallelized.

Any comments or suggestions? Let’s chat!

Conclusion

Finally, several methods and techniques have been proposed to move towards more frugal AI systems: quantification, pruning, approximation, or even new paradigms such as TPGs (of course, the examples given in this article are far from exhaustive). In particular, these approaches will make it possible to reconcile on-board targets and artificial intelligence-based algorithms with their resource requirements.

However, the key to optimizing the performance of an AI algorithm is to know what quality we want to guarantee at the output of the algorithm. From there, we can explore new quality/performance tradeoffs using the techniques described above.

• Sources

^[1] Iandola, Forrest N., et al. “SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and< 0.5 MB model size.” arXiv preprint arXiv:1602.07360 (2016).
^[2] Milot, Quentin, et al. “Wordlength Optimization for Custom Floating-point Systems.” Design and Architectures for Signal and Image Processing: 17th International Workshop, DASIP 2024, Munich, Germany, January 17–19, 2024, Proceedings. Springer Nature, 2024.
^[3] Brown, Tom B. “Language models are few-shot learners.” arXiv preprint arXiv:2005.14165 (2020).
^[4] Kelly, Stephen, and Malcolm I. Heywood. “Emergent tangled graph representations for Atari game playing agents.” Genetic Programming: 20th European Conference, EuroGP 2017, Amsterdam, The Netherlands, April 19-21, 2017, Proceedings 20. Springer International Publishing, 2017.
^[5] Desnos, Karol, et al. “Gegelati: Lightweight artificial intelligence through generic and evolvable tangled program graphs.” Workshop on Design and Architectures for Signal and Image Processing (14th edition). 2021.