GB2584614A

GB2584614A - Optimising building energy use

Info

Publication number: GB2584614A
Application number: GB1906986.3A
Authority: GB
Inventors: Rastogi Parag; Seyedzadeh Saleh; Oliver Stephen; Parry Colin; Wegienka Alan
Original assignee: Arbnco Ltd
Current assignee: Arbnco Ltd
Priority date: 2019-05-17
Filing date: 2019-05-17
Publication date: 2020-12-16
Anticipated expiration: 2039-05-17
Also published as: GB2584614B; GB201906986D0

Abstract

An optimising controller controls one or more of a mutation engine, a feature generator and an energy-estimation model. Building data is modified or "mutated" to generate modified building data representing changes to one or more physical components of the building. The modified building data is converted into a numeric feature vector that may be provided as input to the energy-estimation model. The energy-estimation model is configured to, in turn, estimate an energy use metric. The energy use metric is used by the optimising controller, in an iterative process, to determine a modification to the building that improves the energy use metric of the building. For example, the optimising controller may output one or more modifications, e.g as represented by modified building data, that improve an energy efficiency of the building. The non-linear energy-estimation predictive model is parameterised using a set of trained parameters and may be based on gradient boosted regression tress, neural networks, gaussian process regression or support vector machines.

Description

Intellectual Property Office Application No. GII1906986.3 RTM Date June 2019 The following terms are registered trade marks and should be read as such wherever they occur in this document: Pareto (Page 11) Python (Page 29) Java (Page 29) Intellectual Property Office is an operating name of the Patent Office www.gov.uk/ipo Optimising Building Energy Use

FIELD OF THE INVENTION

The present invention relates to optimising the energy use of a building.

Certain examples describe a system and a method for determining modifications to a building, such as modifications to a set of physical components, that improve an energy use metric for the building. The present invention may be seen to reside in the field of energy systems engineering.

BACKGROUND OF THE INVENTION

Reducing energy use is a pressing problem for the modem world. Climate change studies show ongoing changes in the global climate. These include rising land and ocean temperatures. The studies indicate that human activity is the leading cause of these changes, in particular the emission of so-called "greenhouse" gases. There is evidence that buildings are a major source of greenhouse gas emissions. For example, buildings are respectively responsible for 46% and 40% of all CO2 emissions in the United Kingdom and United States. in order to address the problem of climate change, energy systems engineers are tasked with developing solutions to reduce building energy consumption and increase building energy efficiency. Solutions are desired that may be applied to both new and existing buildings, e.g. that improve energy efficiency when constructing and retrofitting buildings.

To facilitate comparisons of energy consumption, a number of energy use metrics have been proposed. These allow comparisons between different levels of energy efficiency. An energy use metric may be determined by simulating the energy use for a building. This may be used to assess the current energy use of a building. Simulations may receive data representing properties of a building, for example, building dimensions, building material types, building surface types and dimensions (e.g. for walls, floors or windows), building insulation properties, and building age. These simulations may take minutes for a small building and hours for a large, complex building.

US 2010/0305998 Al discloses an iterative algorithm for evaluating a plural number of energy-saving measures. This document describes the use of an evolutionary algorithm to introduce random changes within a set of building properties. It teaches that existing energy modelling programs may be used to evaluate energy use from a determined combination of energy saving or general improvements.

US 9026405 describes a tool for facilitating a home energy audit. An energy simulation engine may be used as part of the tool to provide data analysis.

Parag Rastogi et al, in their 2017 paper "Gaussian-Process-Based Emulators for Building Performance Simulation" presented at the 2017 Building Simulation conference in San Francisco, USA, describe an emulator of a building-energy performance simulator. The emulator implements Gaussian-process regression models to provide a non-linear prediction of annual energy-consumption of a building based on building and weather data.

Saleh Seyedzadeh et al, in their 2018 publication in Visualization in Engineering "Machine learning for estimation of building energy consumption and performance: a review", provide an overview of machine learning techniques that may be used to make energy predictions.

Despite these proposed solutions there is still a desire for methods and systems to enable the energy efficiency of a building to be improved, especially those that operate in a mathematically-rigorous manner yet that are easy to use and interpret.

SUMMARY OF THE INVENTION

Aspects of the present invention are set out in the appended independent claims Variations of these aspects are set out in the dependent claims.

Further features and advantages of the invention will become apparent from the following description, which is made with reference to the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

Figure 1 is a schematic illustration of a system for determining modifications to a building according to an example; Figure 2 is a schematic illustration of an energy use optimiser according to

an example;

Figure 3 is a schematic illustration showing the use of a modification database according to an example; Figure 4 is a schematic illustration showing an architecture for training a predictive model according to an example; Figure 5 is a schematic illustration showing an architecture optimising an energy efficiency metric according to an example; Figures 6A to 6C are schematic illustrations of example portions of building data; Figure 7 is a schematic illustration showing replacement of a portion of building data according to an example, Figure 8 is a flow diagram showing a method for determining modifications to a building according to an example; Figure 9 is a flow diagram showing a method of training a non-linear energy-estimation model according to an example; and Figure 10 is a schematic diagram showing a non-transitory computer-readable storage medium that stores instructions to implement certain example methods.

DETAILED DESCRIPTION OF THE INVENTION

Certain examples described herein enable modifications to a building to be determined. The modifications are provided to improve the energy use of a building as measured with a suitable metric. For example, the modifications may improve the energy efficiency of the building. An optimising controller may be configured to determine the modifications. The optimising controller controls one or more of the following: a mutation engine, a feature generator and an energy-estimation model. Building data relating to a building is obtained. This building data is modified or "mutated" to generate modified building data representing changes to one or more physical components of the building. The modified building data is converted into a numeric feature vector that may be provided as input to the energy-estimation model. The energy-estimation model may be a non-linear model based on modelling techniques such as Gaussian processes or a neural network architecture. The energy-estimation model is configured to, in turn, estimate (i.e. predict) an energy use metric. The energy use metric is used by the optimising controller, in an iterative process, to determine a modification to the building that improves the energy use metric of the building. For example, the optimising controller may output one or more modifications, e.g, as represented by modified building data, that improve the energy efficiency of the building (e.g. that lower energy use and/or that reduce energy loss).

In certain cases, the energy-estimation model is a non-linear predictive model that emulates a building energy simulator, where the building energy simulator provides a simulated energy consumption for the building. The building energy simulator may be what is referred to as a building performance simulator. Building energy simulators may take minutes or hours to simulate energy consumption based on a set of input building properties. For example, they may simulate heat and mass transfer in relation to the building. Certain examples described herein, train the predictive model on input and output data for the building energy simulator. A prediction (i.e. an inference operation) for the predictive model may be orders of magnitude faster than the building energy simulator. As such, it is possible for the optimising controller to evaluate many different predicted energy efficiency metrics for many different sets of modified building properties and determine particular sets of modified building properties that improve the energy use metric, e.g as part of an optimi sati on procedure.

Determining an energy use metric for a building involves a number of complex engineering calculations. For example, an energy use metric is often a complex, non-linear function of high-dimensional data, such as hundreds or thousands of different building property values that may vary with time. The calculations may also be non-differentiable, e.g. may comprise discrete combinations that are not continuous, and may be difficult to map deterministically to a numeric domain, e.g. different choices in the calculations may be made based on the experience of a building services engineer. This often results in difficulties when constructing automated systems that provide an output to improve the energy use metric. Difficulties such as these may be reduced using the examples described herein.

Certain examples described herein determine modifications for a building. The term "building" as used herein may refer to any structure with one or more surfaces, such as structures comprising at least one interior space that is defined within a set of enclosing surfaces (e.g. walls, windows, roofs etc.). The building may comprise a domestic building, e.g. a house or apartment, a commercial building, e.g. an office, warehouse, retail outlet or factory, and/or a public building, e.g. a hospital, school, library or leisure complex. The term "building" may cover any structure that consumes energy, e.g. during its use. The building may be permanent or temporary. The term 'modifications" as used herein may refer to indicated changes to one or more properties of a building. These properties may comprise properties that relate to physical components of the building, such as walls, doors, floors, ceilings, roofs, heating systems, cooling systems, air flow systems, etc. The properties of a building may comprise, amongst others: dimensions of the building; characteristics of one or more surfaces of the building (e.g. material(s), insulation type, construction type etc.); characteristics of one or more heating, ventilation and cooling systems installed as part of the building; characteristics of one or more other environmental systems of the building (e.g. lighting systems, sewage and water systems etc.); and characteristics of one or more energy generation and/or supply systems (e.g. solar generation capacity, electricity supply systems etc). Certain properties may be modifiable, while other properties may be fixed. Whether a property is modifiable or fixed may be a configurable parameter.

Certain examples described herein seek to optimise an energy use metric. The term energy use metric" as used herein may refer to a scalar or multi-dimensional measure of energy use or efficiency. The energy use metric may indicate a measure of energy use or consumption, representing an amount of energy used over a predefined time period. In certain cases, an energy use metric may be based on an energy used by a building over a unit time period, such as an energy consumption in Joules or Watts-hours (J or Wh), or a certain power draw at a specific point in time, e.g., peak power in Watts at a specific time of day and year. Energy may be consumed to maintain a desired environmental configuration, e.g. to maintain a desired internal temperature, humidity and/or air flow. Energy efficiency is the reduction in energy consumption while maintaining the desired environmental conditions. Energy consumption or efficiency may be defined relative to a unit area of a building, e.g. normalised to a metric that is evaluated per m2 such that different buildings may be compared. In one case, the energy use metric may be based on an indoor environmental performance metric, where the energy use is a function of this metric. In certain cases, energy use or efficiency may be measured in terms of a level of carbon dioxide emissions (e.g. in tonnes per year).

In certain cases, an energy use metric may be based on a ratio of a minimum energy use for a building compared to an actual energy use. Similarly, the energy use metric may comprise a ratio of energy use for the building having a first set of building properties and energy use for the building have a second set of building properties. The energy use metric may be a relative or comparative metric. In certain cases, it may be dimensionless (e.g. comprise a value from 0 to 1 or 0% to 100%). An energy use metric may also comprise a discrete classification, e.g. one of a number of defined ranges of a continuous measure.

The examples described herein may be applied to a wide variety of energy use and efficiency metrics, the construction of the systems and methods is such that the energy-estimation model may be agnostic with regard to the form of the metric. For example, the energy-estimation model is trained using a training set that indicates a desired energy use metric, and the energy use metric may be changed by changing the values in the training set. Figure 1 shows a system 100 for determining modifications to a building to improve energy use according to an example. The system 100 comprises a mutation engine 110, a feature generator 120, an energy-estimation model 130 and an optimising controller 140. Each component of the system may be implemented using one or more processors. For example, each component of the system may comprise, in use, a processor that executes computer program code supplied from a coupled memory. Each component may be implemented as a separate thread on a common processor, as a thread on a core of a multi-core processor and/or on separate processors. The system 100 may be implemented using one or more computing devices comprising one or more processors. In certain cases, the system 100 may be implemented as a networked distributed system, where each component may be implemented using a separable computing device that is communicatively coupled to a network to communicate data as described.

The system 100 of Figure 1 may be applied on a building-by-building basis.

For example, a building may be selected for improvement and the system 100 applied to that building. In Figure 1, the mutation engine 110 receives an original building definition file 150 for a given building and generates one or more mutated building definition files 160. Each building definition file comprises building data representing physical properties of the building. In one case, the building data may comprise variable definitions within a predefined format. In one case, the building definition file may comprise a plurality of lines, where each line defines a different property of a building. In one case, the building definition file may comprise a form of computer program code that is parsed by a building energy simulator as described in more detail below. In one case, the building definition file may comprise a text-based INP file for a Simplified Building Energy Model (SBEIV) or an Input Data File (IDF) building model description file for an EnergyPlus model. Other formats and files may also be used.

In the example of Figure 1, the mutation engine 110 is configured to determine modifications to the building data in the original building definition file 150 to output each mutated building definition file 160. These modifications may comprise, among others, changing values in the original building data, replacing portions of text and/or code within the original building data, adding additional portions of text and/or code within the original building data and removing portions of text and/or code within the original building data. The modifications represent changes to one or more physical components of the building, e.g. as defined in the building data. For example, the mutation engine 110 may be configured to change a construction of a particular wall type as defined in the original building data, add a layer of internal and/or external insulation to a particular wall type as defined in the original building data, change a construction of a particular window type as defined in the original building data, add an environmental control apparatus at a location as defined in the original building data, etc. In other examples, the building definition file may be provided as a building data source, e.g. a stream of decoded data packets communicated over a network and/or a data stream from one or more databases.

The feature generator 120 is configured to receive a building definition file and to generate a feature vector from the building data within the building definition file. In the example of Figure 1, the feature generator 120 receives a modified building definition file 160 as output by the mutation engine 110. In Figure 1, the feature generator 120 is configured to parse the modified building definition file 160 and generate a feature vector 170 in the form of an array of numeric values. In one case, the array has a predefined size, e.g. is an N-dimensional array where each dimension has a predefined number of data elements. For example, the array may comprise a 1-D array with 256 or 512 data elements. Each data element may have a defined data type. In one case, all data elements may have a common (i.e, shared) data type. The data type may be a signed or unsigned n-bit integer or an n-bit float. In certain cases, the feature generator 120 may generate an array of normalised numeric values, e.g. 64-bit float values that vary between 0 and 1 or -1 and 1. In a case where the mutation engine 110 outputs a plurality of modified building definition files 160, the feature generator 120 may be configured to take each file and generate a corresponding feature vector 170. The feature generator 120 may generate a feature vector 170 using one or more of, for example, dimensionality reduction, normalisation, feature selection and/or feature extraction. This may also comprise converting discrete classifications and/or text data to a numeric equivalent, e.g. either an integer value or a one-hot representation. Although the components of Figure 1 are described with respect to discrete files, in certain cases, for a plurality of modifications as determined by the mutation engine 110, the feature generator 120 may receive one or more portions of building data representing common (i.e. shared) portions of building data and one or more portions of building data for each modification, e.g. representing the changes to the physical components of the building. The feature generator 120 may then use the common portions of building data to generate a master or template feature vector that may be modified based on the one or more portions of building data for each modification.

Returning to the system of Figure 1, the non-linear energy-estimation model 130 is configured to receive a feature vector generated by the feature generator 120 and to estimate a value for an energy use metric based on the feature vector. In Figure 1, the non-linear energy-estimation model 130 receives the feature vector 170 and outputs a value for the energy use metric 180. The non-linear energy-estimation model 130 is configured to predict a value for the energy use metric 180 based on the feature vector 170. The non-linear energy-estimation model 130 may comprise a non-linear model, such as a multi-layer neural network architecture that applies a non-linearity to an output of each network layer or a Gaussian process regression model. The layers of the neural network architecture may comprise one or more of convolutional neural networks, recurrent neural networks and feedforward neural networks. The output of the non-linear energy-estimation model 130 may have a dimensionality that is smaller than the input feature vector 170. In one case, the output of the non-linear energy-estimation model 130 may comprise a scalar value, e.g. a 64-bit float, that represents the energy use metric. In other cases, the output of the non-linear energy-estimation model 130 may comprise a categorial output, i.e. an array where each element of the array represents a particular category or value, and each element has a value from 0 to 1 representing a weight or probability. For example, in this case, the output of the non-linear energy-estimation model 130 may comprise an array of seven elements representing an energy rating between classes A to G, e.g. where each class represents an underlying range of energy efficiency metric values. Each element in this case may comprise a value between 0 to 1 representing the probability of each class. In this case, the array may be sampled (e.g. by selecting the largest value) to generate a one-hot array where the determined class element has a value of 1 and all other classes have a value of 0. Different approaches may be used depending on the configuration on the system 100 and the energy use metric.

The non-linear energy-estimation model 130 is parameterised by a set of trained parameters. These may comprise one or more of: weights for one or more neural network layers, biases for one or more neural network layers and parameter values for one or more probability distributions. The set of trained parameters result from a training operation performed using a training data set generated using building definition files associated with a plurality of additional buildings. Each sample in the training data set may comprise a feature vector corresponding to one of the plurality of additional buildings and a value for the energy use metric. For example, the training set may comprise a historical data set that comprises a set of samples, each sample in the data set comprising data representative of the properties of a given physical real-world building and a value for the energy use metric for the given building. The value for the energy use metric may be, among other forms, a scalar value or a one-hot array. The samples may be derived from measured values, simulated values or a mix of measured and simulated values.

Each of the mutation engine 110, the feature generator 120 and the estimation model 130 may be implemented as modular system components that are coupled by a common communications bus. In certain cases, each system component may comprise computer program code that is loaded into memory and executed by one or more central processing units. In certain cases, each system component may have a defined application programming interface (API); in this case, the data supplied to each component may comprise data passed to the respective defined interface and/or a reference to data as stored on a storage device (e.g. a system path). Similarly, data output by each component may be stored as an accessible file on a storage device and/or stored within volatile memory and accessed via a returned memory address.

In Figure 1, the mutation engine 110, the feature generator 120 and the nonlinear energy-estimation model 130 are controlled by the optimising controller 140. The optimising controller 140 iteratively activates the mutation engine 110, the feature generator and the estimation model 130 to determine a modification to the building that improves the energy use metric. This is shown by the dotted line in Figure 1.

The optimising controller 140 may comprise a supervisory process that initialises each of the mutation engine 110, the feature generator 120 and the estimation model 130. In one iteration, the optimising controller 140 may instruct the mutation engine to generate a set of modified building definition files 160, instruct the feature generator 120 to convert said files 160 into a set of feature vectors 170 and then instruct the non-linear energy-estimation model 130 to estimate values for the energy use metric 180 for each of the set of feature vectors 170. As shown in Figure 1, the optimising controller 140 may receive the values for the energy use metric 180 from the non-linear energy-estimation model 130, evaluate these values and use the result to instruct a next iteration. In the next iteration, the optimising controller 140 may instruct the mutation engine 110 to perform a particular set of modifications based on the evaluated results. For example, the optimising controller may instruct the mutation engine 110 to modify certain properties and/or physical components.

In certain cases, an output of the system 100 may comprise a set of modified building definition files 160. These each may represent modifications to physical components of the building that improve the energy use metric. In certain cases, the set of modified building definition files 160 may be output without processing; in other cases, modifications expressed in the modified building definition files 160 may be extracted and processed. For example, the changes between the original building definition file 150 and each of the set of modified building definition files 160 may be determined and presented.

In one case, modifications may be grouped based on one or more of, for example, physical component, building area, and type of modification.

In one case, optimising controller 140 may be configured to optimise an objective function. The objective function may comprise a loss or cost function and may be constructed based on one or more defined objective function terms. In the present example, one of the one or more defined objective function terms may be based on the energy use metric estimated by the non-linear energy-estimation model 130. The optimising controller 140 may be set to minimise an energy term in order to reduce an energy consumption or to maximise an energy term in order to increase an energy efficiency. It should be understood that the form of the objective function may vary and may depend on the energy use metric that is being used.

In certain cases, the optimising controller 140 may be configured to optimise an objective function subject to one or more defined constraints. In one case, these constraints may form part of the objective function. The constraints may comprise a range of values for the energy use metric. If a modification enacted by the mutation engine 110 does not result in a value for the energy use metric 180 that meets the defined constraints, then the modification may be avoided and/or changed. In one case, the optimising controller 140 may use gradient methods (such as gradient descent) to determine a modification to be applied by the mutation engine 110. In certain cases, the optimising controller 140 may use search methods (e.g, grid search) to determine modifications to the original building definition file 150, e.g, by evaluating extrema over the grid. In one case, there may be hundreds, thousands or millions of iterations.

In certain cases, the optimising controller 140 may be configured to optimise a multi-objective function. In this case, there may be a plurality of objective function terms relating to multiple defined objectives. A value of the multi-objective function may then be maximised or minimised by the optimising controller 140 (e.g. depending on configuration) by instructing changes to physical components of the building, as enacted by the mutation engine 110. For example, a first objective function term may be based on an energy use metric estimated by the non-linear energy-estimation model HO as described above. In certain examples, further objective function terms may be added. For example, a second objective function term may be based on a resource use associated with implementing a difference between a mutated building definition file 160 and the original building definition file 150. A resource cost may be defined in terms of one or more of: material quantity, monetary cost, gas emission cost of the change time to install, number of required fitting engineers, and spatial footprint. A resource cost may depend on one or more properties of the building, e.g. as defined in the building definition file 150 or in additional data. For example, a resource cost may be based on a geographical location of the building. In certain cases, a third objective function term may be based on a change in building utilisation associated with implementing the difference between a mutated building definition file 170 and the original building definition file 150. This may represent a disruption to the building use that would occur if one or more modifications were applied to the building. For example, this may be defined based on areas of a building. These areas may represent zones or rooms. Modifications may affect different areas of the building. In one case, a change in building utilisation may be represented by a binary variable indicating whether the area is usable based on the modification, e.g. a change to a wall in an area may render the area unusable for the expected period of time that the proposed modification is to be carried out and so a value of 0 may be applied. In this case, the objective function may be constructed so as to maximise usability during construction (e.g. maximise the objective function term). In certain cases, usability may be defined on a normalised scale (e.g. 0 to 1). A usability value for a given modification may be determined using a modification database as described later below.

In certain cases, e.g. when performing multi-objective optimisation as described above, there may be a plurality of modifications that each provide an optimised result. In this case, the optimising controller 140 may output a number of Pareto optimal solutions that define a Pareto front. Pareto optimal solutions may indicate that no one individual objective (e.g. as represented by an objective function term) may be improved without degrading another objective, e.g. each solution or set of variable values may be equally suitable. In this case, the optimising controller 140 may be configured to output the multiple sets of modifications.

Figure 2 shows a system 200 for determining modifications to a building to improve energy use according to another example. The system 200 comprises an energy use optimiser 210. The energy use optimiser 210 may comprise the system 100 of Figure 1 or another suitably-configured system. The energy use optimiser 210 may be implemented by a computing device comprising at least one processor and a memory. The energy use optimiser 210 is configured to receive data representing building properties 220 and to determine one or more renovation configurations 230. The building properties 220 may comprise properties for an existing building in the form of a building definition file as shown in Figure 1. Each of the one or more renovation configurations 230 comprises data indicating one or more changes to the existing building that are determined to provide an improvement in an energy use metric for the building. The one or more renovation configurations 230 may be generated based on one or more sets of modified building properties, e.g. may be based on modified building definition files 160 as output following multiple iterations of the optimising controller 140 in Figure 1. In certain cases, the one or more renovation configurations 230 may be generated by processing one or more sets of modified building properties.

In Figure 2, the energy use optimiser 210 accesses a modification database 240 to determine the one or more renovation configurations. The modification database 240 comprises a plurality of modification records. Each modification record may indicate a predefined change in one physical component of the building, e.g. as represented in building data of a building definition file. Each modification record may comprise modification data indicating changes that may result in changes to one or more thermo-physical properties of a building. For example, the modification database 240 may comprise modification data associated with previous renovation or retrofit operations where one or more changes were made to properties of physical components of a building, e.g. as defined in the aforementioned building data. Alternatively, and/or additionally, the modification database 240 may comprise modification records associated with potential or possible renovation or retrofit operations. For example, a modification indicated by one modification record may be installation of insulation of a particular type. This may provide a decrease in the thermal transmittance of one or more surfaces of the building. The modification data may be normalised, e.g. processed to indicate changes per unit area of a building, such as per m2.

The modification data may comprise a plurality of entries where each entry comprises a set of modifications to one or more values of the building properties 220. These entries may be used to determine modified building properties during operation of the energy use optimiser 210, e.g. may be used to determine candidate portions of the original building definition file 150 to modify to generate one or more modified building definition files 160 as shown in Figure 1.

In Figure 2, the energy use optimiser 210 is also communicatively coupled to a user interface 260. The user interface 260 may comprise a display and one or more user input devices. The user input devices may comprise one or more of a keyboard, mouse, touchscreen, voice interface etc. The user interface 260 and the energy use optimiser 210 may be provided in a common computing device, such as a desktop computer, a laptop, a tablet, or a smartphone. In other cases, the energy use optimiser 210 may be remote to the user interface 260, e.g. may be implemented by a server computing device that is communicatively coupled to one or more networks. In this case, the user interface 260 may form part of a separate client computing device.

The user interface 260 in Figure 2 is configured to receive desired values for use in an optimisation to be performed by the energy use optimiser 210. These may comprise desired values for one or more objective function terms and/or one or more constraints for said terms. The desired values may be used by the optimising controller 140 of Figure 1. In one case, the energy use optimiser 210 is configured to iteratively determine whether a set of modifications to the building properties 220 exist that provide a desired improvement in the energy use metric while meeting the received one or more constraints. The one or more constraints may represent resource constraints, such as a time period in which the renovations need to be made and/or that the building has certain characteristics that exclude certain modifications (e.g. a building may be located in an earthquake zone that constrains the structures that may be changed in one or more modifications). Data indicating the one or more constraints may be received by the optimising controller 140 of Figure 1 and used to construct one or more objective functions. Alternatively, and/or additionally, the one or more constraints may be used to filter the modification records 250 that are retrieved from the modification database 240 during the operation of the energy use optimiser 210. The desired improvement in the energy use metric may indicate a desired energy efficiency rating category and/or a desired energy efficiency metric value.

Figure 3 shows an example 300 of an optimiser 310 that may be used as part of the energy use optimiser 210 of Figure 2. The optimiser 310 may be an implementation of the optimising controller 140 of Figure 1. In the example 300, the optimiser 310 is communicatively coupled to a modification database 340. As part of an initialisation routine, the optimiser 310 loads a building definition file 320 that represents a building to be improved. The optimiser 310 stores the building definition file 320 in memory. The optimiser 310 uses the contents of the building definition file 320 to make one or more queries to the modification database 340. For example, the optimiser 310 may parse the building definition file 320 and extract a set of physical components that define the building.

These may comprise one or more surfaces such as walls, roofs, ceilings, floors, windows etc. The physical components may be internal or external, e.g. with reference to the building and/or an external environment. The optimiser 310 may then use the contents of the building definition file 320 to construct a set of queries that relate to one or more of the physical components extracted from the file. The results of the set of queries may comprise modifications to those physical components. Additional data from the building definition file 320 may be used to filter the results of the query, e.g. restrict results to matching building types and/or geographical areas. The results of the set of queries are used by the optimiser 310 to build at least one modified building definition file 350.

The curved dashed arrow in Figure 3 indicates that the optimiser 310 uses the at least one modified building definition file 350 to obtain a value for an energy use metric 370. In this example, this is a Building Energy Rating (BER) value in a form that is the same as that output by a Simplified Building Energy Model (SBEM) simulation engine. In another case, this may be a value output by an EnergyPlus simulation engine, e.g. as developed by the National Renewable Energy Laboratory of the United States of America. The non-linear energy-estimation model 130 as shown in Figure 1, as opposed to a SBEM simulation engine, may be used to predict a BER value based on a particular modified building definition file 350, e.g. as converted into a feature vector by the feature generator 120. The BER value may comprise a scalar float value that is returned to the optimiser 310.

In the example of Figure 3, the optimiser 310 uses the received value for the energy use metric 370 to change the modifications that are made to the one or more physical components extracted from the building definition file 320. For example, the results of the set of queries may indicate that a thickness of a surface of the building may be varied within a range. Values within this range may be set in a plurality of modified building definition files 350 and the plurality of returned values for the energy use metric 370 may indicate a rate of change of the energy use metric with respect to the range. In another case, a modification may comprise a discrete change, e.g. using a heat recovery system as opposed to not using a heat recovery system. Again, the optimiser 310 may generate modified building definition files 350 that reflect the range of possible discrete changes, e.g. as indicated by the query results, and instruct the prediction of values for the energy use metric 370. By repeating a plurality of iterations of the loop shown in Figure 3, the optimiser 310 is able to determine modifications that optimise the value of the energy use metric 370. Figure 4 shows a system 400 for training a non-linear energy-estimation 10 model according to an example. The system 400 comprises a feature generator 420 and a non-linear energy-estimation model 430. The feature generator 420 may comprise an implementation of the feature generator 120 in Figure 1 and the non-linear energy-estimation model 430 may comprise an implementation of the non-linear energy-estimation model 130 of Figure 1. The system 400 may be used to train the non-linear energy-estimation model 130 of Figure 1.

As well as the feature generator 420 and the non-linear energy-estimation model 430, the system 400 further comprises a training data generator 450 and a building energy simulator 460. The training data generator 450 receives building data 452 for a plurality of buildings. This may comprise data regards a plurality of physical buildings in the real-world. The building data 452 may comprise building definition files for a set of buildings, e.g. such as a set of INP or 1DF files. In another case, the building data 452 may comprise a list of building identifiers and may retrieve building data from one or more data sources.

The training data generator 450 outputs training data 454 in the form of a plurality of data portions relating to a respective plurality of buildings. In one case, the training data 454 may relate to the same buildings as the building data 452. In another case, the training data generator 450 may perform operations similar to the mutation engine 110 of Figure 1 to generate synthetic building data based on real-world building data. For example, multiple building definition files may be generated from a single original real-world building definition file by mutating the contents of the original file. In one case, the training data 454 comprises a plurality of building definition files, such as a set of INP or 1DF files (e.g. a batch of electronic text-based definitions).

Each sample or record of the training data 454 may have a different data length. For example, the file format for a building definition file may allow building definitions having an arbitrary data length and complexity. For example, even for one particular physical building, certain properties may be explicitly defined (e.g. "DESTRAT-FAN = NO") or defined implicitly (e.g. by omitting a line setting the "DESTRAT-FAN" property). Also, certain building definition files may define unused physical components and/or define groups of repeated properties by a common reference or by explicit repetition. The training data 454 is of a form suitable for input into the building energy simulator 460. The building energy simulator 460 may comprise an SBEM or EnergyPlus simulation engine that is arranged to simulate heat and mass transfer in relation to the building to provide a simulated energy consumption for a building. For example, the building energy simulator 460 may solve one or more sets of differential algebraic equations. The building energy simulator 460 may comprise a sewer computing device that implements a physics model to determine the energy consumption of a building defined in a training data sample. In other cases, the building energy simulator 460 may comprise a locally-executed copy of computer program code that implements an SBEM or EnergyPlus simulation engine. The building energy simulator 460 runs a series of complex calculations and may take hours or days to output a simulated energy consumption. In the present examples, the non-linear energy-estimation model 430 is trained so as to emulate the building energy simulator 460.

This is performed as described below.

In the example of Figure 4, each sample of the training data 454 is supplied to the building energy simulator 460 and the building energy simulator 460 computes a corresponding simulated energy consumption value. Over the set of samples in the training data 454 this generates a set of output data 462. Although Figure 4 shows the building energy simulator 460 being applied to the training data, it should be noted that the training data 454 and the output data 462 may be obtained from historical sources, e.g. from running the building energy simulator 460 over a series of years, without actively running the building energy simulator 460.

To train the non-linear energy-estimation model 430, a set of input-output pairs are supplied. Each input-output pair comprises a feature vector from a set of feature vectors 470 and an output value from the output data 462. The set of feature vectors 470 are generated based on the training data 454 by the feature generator 420, e.g. using a similar process to that described with reference to Figure 1. Each input-output pair may comprise a feature vector that is generated based on data relating to one INP or IDF file that has been used to produce a corresponding BER value by the building energy simulator 460. Each input-output pair may be seen to relate to a building defined in the building data 452 or a synthetic building generated by the training data generator 450. The output of each input-output pair may be seen as a "ground truth" value, e.g. representing a BER value. During training the non-linear energy-estimation model 430 is used to predict a set of values for the energy use metric 480, where each value corresponds to a different input feature vector. For a given input-output pair, the predicted value for the energy use metric is compared with a corresponding "ground-truth" value as provided from the output data 462. The error between the predicted value and the "ground-truth" value may then be used to determine an update to parameters of the non-linear energy-estimation model 430 e g changes to one or more probability distribution parameters and/or neural network parameters. Training may use back-propagation and gradient descent methods. Training may be repeated for multiple iterations through the input-output pairs until the parameters of the non-linear energy-estimation model 430 converge and/or an error across the set of training samples is reduced to a predefined range.

The result of the training process performed by the system 400 is a set of trained parameters for the non-linear energy-estimation model 430. These trained parameters may then be stored, e.g. in a configuration file on a storage device, and subsequently loaded to instantiate the non-linear energy-estimation model 430, e.g. to provide the system 100 of Figure 1. The training shown in Figure 4 may be performed periodically over time, or in an online manner, as new building data is collected.

Figure 5 shows another example of a system 500 for determining modifications to a building. The system 500 may be seen as a variation of the system 100 shown in Figure 1. The system comprises a mutation engine 510, a feature generator 520 and an optimising controller 540. These may be implemented in a similar manner to the mutation engine 110, the feature generator 120 and the optimising controller 140 of Figure 1. In the present example, the mutation engine 110 is communicatively coupled to a modification database 512. The modification database 512 may be implemented in a similar manner to the modification databases 240 and 340 in Figures 2 and 3. The modification database 512 supplies modification data 514 to the mutation engine 510 to enable it to modify building data provided within a building definition file 550 to generate a set of one or more modified building definition files 560. The feature generator 520 receives the modified building definition files 560 and generates a respective set of feature vectors 570. This may be performed as described with reference to Figure 1.

The system 500 of Figure 5 also comprises an energy estimator 530, a resource estimator 532 and a building operation estimator 534. The energy estimator 530 may comprise the non-linear energy-estimation model 130 of Figure 1. Such a non-linear energy-estimation model may be instantiated using a set of trained parameters, e.g. as generated using the system 400 of Figure 4. The energy estimator 530 determines a first objective function term 580. The first objective function term 580 is based on an energy use metric, where the energy use metric may be predicted by a non-linear energy-estimation model such as 130 or 430. The resource estimator 532 determines a second objective function term 582 based on a resource use associated with implementing a difference between a mutated building definition file 560 and the original building definition file 550. The building operation estimator 534 determines a third objective function term 584 based on a change in building utilisation associated with implementing the difference between a mutated building definition file 560 and the original building definition file 550.

The three objective function terms 580, 582 and 584 are each supplied to the optimising controller 540. As described with reference to Figure 1, the optimising controller 540 is configured to iteratively optimise an objective function comprising the three objective function terms 580, 582 and 584. The optimising controller 540 may use a standard multi -objective optimiser that is configured to optimise an objective function containing the three objective function terms 580, 582 and 584. The optimising controller 540 may also receive one or more constraints 590 and a target value 592. The constraints 590 may indicate ranges for one or more of the objective function terms, e.g. minimum and/or maximum values for each of these terms. The target value 592 may represent a desired value for the first objective function term, e.g. a desired value for the energy use metric. The optimising controller 540 may be configured to optimise the objective function to achieve the target value 592 while minimising the second and third objective function terms 582 and 584 and maintaining the constraints 590. If no target value 592 is supplied, then the optimising controller 540 may seek to maximise an energy efficiency metric associated with the first objective function 30 term while minimising the second and third objective function terms 582 and 584. Constraints 590 may be applied if supplied, but they may be omitted in system 500 if desired. The optimising controller 540 is configured to control the modifications that are applied by the mutation engine 510 to iteratively optimise the objective function, e.g. in a similar manner to the optimising controller 140 of Figure 1. For example, in each iteration a plurality of modified building definition files 570 may be generated by modifying properties of physical components of the building as defined in the original building definition file 550. Each modified building definition file represents a different change in the building configuration and is used to generate a different value for each of the three objective function terms 580, 582 and 584.

In certain cases, the optimising controller 540 may filter the modified building definition files 560 based on the three objective function terms 580, 582 and 584. For example, the modified definition files 560 may be ordered based on one or more of the three objective function terms 580, 582 and 584 and files below a predetermined threshold and/or that do not meet any supplied constraints 590 may be discarded. In one case, the modified building definition files 560 may be first ordered based on the first objective function term 580, then ordered on the second objective function term (e.g. files with a common first objective function term are ordered based on the second objective function term), and then ordered on the third objective function term (e.g. files with a common second objective function term are ordered based on the third objective function term). In one case, modified building definition files 560 below a configurable point in an ordered list are discarded, e.g. only the top x modified building definition files 560 that meet any supplied constraints 590, as ordered, may be retained The configurable point, x, may be a parameter of the optimising controller 540 that is tuned based on performance. The modified building definition files 560 that are retained may then be further modified by the mutation engine 110 to generate a next set of modified building definition files 560 in a next iteration, e.g. the modifications may be retained and/or refined over iterations. The optimising controller 540 may repeat these iterations until one or more stopping criteria are met (e.g. a target value 595 is met and/or the first objective function term 580 is maximised) and/or a predefined length of time has elapsed. Modified building definition files 560 that remain following a final iteration may be supplied to a user, e.g. via the user interface 260 of Figure 2 or otherwise. These final modified building definition files 560 may be processed before being output, e.g. files with similar modifications may be grouped for comparison. In certain examples, one of the final modified building definition files 560 may be selected to modify the physical building, e.g. be used to instruct a building modification that improves an energy efficiency of the building.

In one case, the mutation engine 510 may be configured to receive a mutation configuration file comprising mutation parameters for one or more properties defined in the building data. In this case, each mutation parameter may control a rate of change for a corresponding property. In one case, the mutation parameters may comprise user-selected "hardness" parameters than indicate a rate of change for a property. For example, a value of 0 may indicate that a given property will definitely change during an iteration of the optimising controller 540 and a value of 1 may indicate that the given property will not change in the iteration. In certain cases, a value between 0 and 1 may indicate a level of change that is permitted, e.g. a value of 0.5 may indicate that the property is to change in 50% of iterations.

Figures GA to GC are examples of different portions of building data. Figure 6A shows a portion of building data 600 that defines a construction of an external solid wall. Figure 6B shows a portion of building data 610 that defines a particular portion of wall that uses the construction of Figure 6A. The portion of building data 610 in Figure 6B may define the thenno-physical properties of a wall, e.g. its length, area and orientation. Figure 6C shows a portion of building data 620 that may be used to define a zone or an area of a building. This zone or area may use the wall as defined in Figure GB. The portion 620 may comprise one or more binary variables indicating a presence or absence of one or more environmental control systems and/or one or more categorical variables representing a particular class of installed equipment, such as lighting or power configurations. The portions 600, 610 and 620 shown in each of Figures 6A to 6C may form part of a common building definition file, such as an IMP or 1DF file.

The building data shown in Figures 6A to 6C may be used to define different building components and materials as objects using a specific format. Different object types may be combined and an arbitrary number of objects of different types may be used to specify a configuration of a building. The building data may be obtained from architecture and/or engineering plans for the building, e.g. data files defining an architectural design, one or more computer-aided design files and/or building information data files. Additionally, or alternatively, the building data may be directly measured from the building itself Figure 7 shows an example 700 of how a mutation engine may use a modification database to modify building data, e.g. as shown in Figure 6A. The example may be used as part of the implementation of the mutation engine 110 in Figure 1 or 510 in Figure 5, Figure 7 shows an original portion 710 of the building data associated with one of a plurality of ph ysi cal components of the building. For example, this may comprise a portion of building data similar to that shown in Figure 6A that defines a construction of an external solid wall. The original portion 710 may be obtained from an input building definition file, e.g. file 150 or 550 in Figures 1 and 5. In certain cases, the mutation engine parses the input building definition file to extract this data, e.g. to determine lines of the file that relate to a particular object. Figure 7 shows a query builder 720 that may form part of the mutation engine. The query builder 720 is configured to receive the original portion 710 and construct a query for a modification database 730. For example, the query builder 720 may query the database for modifications that relate to an object, e.g. a physical component of a building, that is defined in the original portion 710. In certain cases, the query builder 720 may use other information in a building definition file to constraint the query, e.g. to limit to a particular geographical area or building type. The query constructed by the query builder 720 is sent to the modification database 730, which returns modification data 740 comprising possible modifications relating to the original portion 710. The modification data 740 may comprise modification records that indicate possible changes to properties of the object that is defined in the original portion. In certain cases, instead of or as well as restricting the query scope, the modification data 740 may be filtered based on the present building data. In one case, the modification data 740 is used to determine a replacement portion 750 for the original portion 710 of the building data The replacement portion may be used to replace the original portion in a mutated building definition file.

In the example 700 of Figure 7, the original portion of building data 710 defines a construction of an external wall with a particular U value: 2.1 W/m2K. The replacement portion 750 comprises a modification that reduces the U value to 1.5 W/m2K. For example, the modification database 730 may store a modification record that indicates that the external wall defined in the original portion 710 may be modified by adding a layer of extruded polystyrene and plasterboard. This modification data 740 that is returned may define a portion of building data itself, e.g. comprise replacement portion 750, or may comprise data that is useable to construct the replacement portion. For example, in one case, a new U value may be computed by determining a thermal resistance of the unmodified wall (Raid = 1/(2.1)) and adding the thermal resistances of the added layers (Radd -e.g. of the extruded polystyrene and plasterboard), such that lion., = 1 / (Roid + Rada). Although not shown in Figure 7, the replacement portion 750 may also indicate other modified properties, e.g. a wall thickness may be modified.

In one case, an object with a modified set of properties may form the basis for other components of the building, e.g. the portion of building data 600 shown in Figure 6A may relate to a wall construction that forms part of a wall instance (e.g. portion 610) that then forms part of a building zone instance (e.g. portion 620), ln certain cases, a building may have a plurality of areas or zones that are defined in the building definition file. In this case, a feature generator, such as feature generator 120 in Figure 1, 420 in Figure 4 or 520 in Figure 5, may be configured to generate a numeric input value, e.g. for an element of a feature vector, by determining an area-weighted value from the building data over the plurality of areas as defined in the building data.

In one case, the action of the non-linear energy-estimation model may be represented as prediction model configured to predict a BER value, 9, based on a feature vector X: 9 = f(X) In this case, each feature vector X represents a distinct building or variation of a building (e.g. one data point). The feature vector X may comprise an array of one or more dimensions. Each element xi of the feature vector X may represent a feature. Features may be determined by normalising numerical values within the building data and/or converting categorical information (e.g. classes within a set) into a numeric equivalent (e.g. in a set of 8 labels each label may have a value between 0 and 7). During training, the feature vectors 470 may be represented as a matrix X of feature vectors X and the output data may be represented as a vector Y. The features that are generated may depend on the implementation and the building data that is available. Certain features may be weighted by area or zone. Examples of certain features are provided below.

In general, an area-weighted feature xi may be determined by computing values of a feature icz per zone, e.g. section of a building as defined in a building definition file (see portion 620 of Figure 6C) and weighting each feature x, by the area of the zone A,. A zone may correspond to a room or a particular internal area of a building, such as an atrium. If a building has Z zones, then the feature xi may be computed as: Ezz=i xz * Az xi -izz=i Az For example, x, may comprise an internal heat gain for a zone, e.g. based on an occupation metric and/or equipment installed within the zone. The occupation of a zone, the size of a zone, and/or equipment that is installed within the zone may be defined in the building data. ;A similar approach may also be applied to determine features relating to heating, cooling and/or ventilation. For example, another feature xi may comprise a heated area ratio that is computed as: V-181-1 Az xi = Ezz=i Az where 6H is a binary variable that is determined based on whether a zone is served by a heating system (e.g. 1 = the zone is served and 0 = the zone is not served), Az is the floor area of a zone and Z is the number of zones as above. Similar computations may be used to determine a cooled area ratio, a ventilated area ratio and an unconditioned area ratio. ;Whether a zone is heated, cooled, ventilated or the like may be defined in the zone definition in the building data Features relating to surfaces such as walls, floors, and ceiling may also be area weighted. For example, one surface feature may comprise an opaque conduction factor xi (e.g. a conduction of opaque surfaces such as walls) that is computed as: ELI_ Us * As xi = 1As where s is a surface in the building, there are S surfaces in total, A, is the area of a given surface s and U, is the thermal conductivity of the surface s. The thermal conductivity for a particular surface Us may be determined based on building data such as is shown in Figure 6A (e.g. wall construction data), wherein the surface configuration (e.g. As) may be determined based on the building data shown in Figure 6B (e.g. wall object data). Features that may be determined in this manner include an area-weighted conduction factor for non-opaque surfaces (e.g. windows) and an area-weighted solar gain co-efficient (e.g. U and G values). Another surface-related feature Xi may comprise a surface-to-surface ratio for different types of surfaces. For example, a window-to-wall ratio may be computed as: Eww=1,4W xi

FA

where A" is the area of the wth window, W is the total number of windows and FA is the area of the floor of the building (or "footprint"), As with the previous examples Aw and FA may be determined from the definitions within the building definition file. Similar determinations may be made to generate values for a window-to-floor ratio feature, a roofto-wall ratio feature and an internal-to-external partition ratio feature.

Certain features may be determined based on geographical information for the building. For example, based on a location (e.g. as defined by a latitude and a longitude or a nearest city), climate features may be determined. These may include a monthly average of solar radiation incident on each external surface, where the external surfaces are determined from a parse of the building data, and where the building data indicates a wall orientation (e.g. see portion 610 in Figure 6B), and a monthly average of external temperature.

Building specific features may also be determined. These may include features relating to heating, ventilation and air conditioning (so-called "HVAC" properties). These features may be area-weighted as above and may include a cooling system efficiency, a heating system efficiency and parasitic power usage. Lighting configurations for a zone (e.g. as shown in portion 620 in Figure 6C) may be used to determine the power used for lighting per unit area, where each zone may be weighted by area as above. The energy lost or gained due to uncontrolled ingress or egress of outside air (i.e, infiltration, sometimes referred to as leakage) may also be determined from the building definition file and set as a feature.

The aforementioned features are provided as examples As would be 20 understood, the exact form of the features may vary and the non-linear energy-estimation model may adapt its parameters during a training phase to different feature specifications, e.g, as long as all samples share the same feature specifications.

Figure 8 shows an example method 800 for determining modifications to a building to improve energy use. For example, the method 800 made be performed to determine modifications to improve an energy efficiency of the building. The method 800 may be computer-implemented, e.g, implemented as instructions stored as computer program code that are loaded into memory and executed by one or more processors. The method 800 may be performed using any of the systems of Figures 1, 2, 3 and 5.

At block 810, original building data is obtained representing one or more properties of one or more physical components of the building. The building may be a building undergoing renovation and/or a design for a new building. The original building data may be supplied as a building definition file, such as a text-based INP or IDF file. Examples of building data are shown in Figure GA to GC.

At block 820, modifications to the one or more properties are determined to generate modified building data. This may be performed by a mutation engine such as 110 or 510 in Figures t and 5. Alternatively, it may be performed by the entity performing the method, such as a server computing device. The modifications may be enacted as described with reference to any of Figures 2, 3 and 5.

At block 830, the modified building data is converted into a feature vector. The feature vector comprises an array of numeric values and the array has a predefined size. The conversion may be performed by a feature generator such as 120 or 520 in Figures 1 and 5 or another entity. Each element of the feature vector may have a defined range (e.g. 0 to 255 or a defined data type such as a double -64bit -float). The construction of the feature vector may comprise determining features from building data as discussed above. The output of block 830 may comprise a fixed-length array of a common data type (e.g. an array of 32 floats).

At block 840, the feature vector determined at block 830 is input to a non-linear energy-estimation model. The non-linear energy-estimation model may comprise a model as described with reference to Figures 1, 4 and 5. The non-linear energy-estimation model may be based on at least one of the following types of non-linear regression model: gradient-boosted regression trees, artificial neural networks, gaussian process regression, and support vector machines. The non-linear energy-estimation model is configured to estimate a value for an energy use metric based on the feature vector. The non-linear energy-estimation model may be instantiated based on a set of trained parameters, where the trained parameter values may be determined by a training phase similar to that shown in Figure 4, e.g. based on pairs of building data and BER values. Block 850 comprises using the nonlinear energy-estimation model to predict a value for the energy use metric for the modified building data generated in block 820.

As shown by the dotted line in Figure 8, the method is repeated for a plurality of iterations corresponding to a plurality of modifications. For example, blocks 820 to 850 may be repeated to determine a range of energy use metric for a corresponding range of modifications. The modifications at block 820 may be determined based on the predictions made so far, e.g. based on the output of block 850. For example, modifications that improve the energy use metric (e.g. improve a BER value representing an improved energy efficiency) may be retained and/or further changed based on a rate of change of the improvement (e.g. based on a gradient in one or more dimensions). The method 800 may be repeated for a predetermined number of iterations and/or repeated until one or more stopping criteria are met, such as local or global extrema being located. At block 860, the method further comprises outputting, based on the plurality of iterations, one or more sets of modifications to the one or more properties of the building that improve the energy use of the building.

The repetition of blocks 820 to 850 may comprise part of an optimisation procedure, e.g. as performed by an optimising controller such as 110 or 510 in Figures 1 and 5. The method may thus comprise optimising, over the plurality of iterations, an objective function comprising at least one term determined based on the predicted value for the energy use metric. In one case, the objective function comprises a plurality of terms (e.g. a relates to a multi-objective optimisation). These terms may include one or more of a first term determined based on the predicted value for the energy use metric, a second term determined based on a resource use associated with implementing a difference between the modified building data arid the original building data, arid a third term determined based on a change in building utilisation associated with implementing the difference between the modified building data and the original building data.

In certain examples, the method 800 may comprise evaluating whether the predicted value at block 850 indicates an improvement in the energy use of the building. Responsive to a positive indication, block 820 in a subsequent iteration may comprise determining a further set of modifications to the one or more properties based on the evaluation. For example, this may comprise retaining modified building data that resulted in an improvement, and then further modifying that data.

In certain examples, such as those similar to the example of Figure 7, the method 800 comprises parsing a building definition file for the building to extract the original building data and querying a modification database based on the extracted original building data. In this case, a set of query results are received arid replacement data for at least a portion of the original building data is determined based on the set of query results, the replacement data replacing the portion of the original building data in a mutated building definition file.

In certain cases, for example when the method 800 is performed with the system shown in Figure 2, block 860 comprises outputting one or more renovation configurations for the building. Each renovation configuration may provide an improvement in the energy use metric for the building and may comprise one or more changes to the building that provide a corresponding set of modifications to the therm o-phy si cal properties of the building. For example, a renovation configuration may identify physical components of the building whose properties are to be modified in the proposed renovation (e.g. as embodied in the modified building data). in one case, each renovation configuration may include modification data returned from a query of a modification database, e.g. the modification may be correlated with a modification record that provides further details of the change to the physical components of the building. To renovate the building, one of the one or more renovation configurations for the building is selected and the building is modified according to the modifications therein to change the thermo-physical properties of the building.

Figure 9 shows a method 900 of training a non-linear energy-estimation model. The nonlinear energy-estimation model may be for use in determining modifications to a building to improve energy use.

At block 910, a data set comprising a plurality of training samples is obtained.

Each training sample comprises a building definition file and an energy use metric for a building. The plurality of training samples comprise building definition files of varying lengths, where the energy use metric has been assigned by a building energy simulator that simulates energy consumption for the building and that differs from the non-linear energy-estimation model. For example, the data set may comprise corresponding pairs of data from the training data 454 and the output data 462 as shown in Figure 4.

At block 920, a feature vector is generated for each building definition file within the data set of training samples. The feature vector is a fixed size and each element in the feature vector has a numeric value with a predefined range. Block 920 may be performed by applying the feature generator 420 as described with reference to Figure 4.

At block 930, the non-linear energy-estimation model is trained using the feature vector corresponding to each sample as an input and the energy use metric associated with each sample as a ground-truth value to compare with an output of the non-linear energy-estimation model. Block 930 comprising determining values for a set of parameters that characterise the non-linear energy-estimation model. For example, block 930 may comprise a training phase as described with reference to the non-linear energy-estimation model 430 of Figure 4.

Certain examples described herein may be used to reduce negative environmental effects by indicating improvements to buildings. For example, in certain cases, the systems and methods may be applied to determine modifications to a building that increase its an Energy Performance Certificate (EPC) rating or category, where the EPC rating indicates an efficiency with which the building uses energy, e.g. for environmental control and lighting.

In the past it has been difficult to determine modifications to a building that may improve energy use, as buildings are complex systems that are difficult to model. The non-linear energy-estimation model described herein may, in certain cases, predict a value for a BER and as such emulate an output of a SBEM simulation engine. In certain examples, the nonlinear energy-estimation model may predict at least a portion of an output of a building performance simulator such as an EnergyPlus model. In tests, it is found that the SBEM simulation engine takes a certain amount of time to evaluate a building, e.g in the region of 5-3600 seconds for highly optimised implementations, where performance may depend on building complexity and/or a size of a building definition file (such as an INP file used as input to the SBEM simulation engine). For example, a multi-story office may take much longer to simulate than a simple room. This makes it difficult to evaluate the energy efficiency of large and complex buildings. For unoptimized implementations of the SBEM simulation engine, simulation time may be increased be a large factor. In the past this has rendered the SBEM simulation engine unsuitable for complex building optimisations, e.g. when attempting to select an optimal set of retrofit recommendations for a given building, a single optimisation routine may perform several hundred thousand evaluations. In comparison, in tests, implementations of the non-linear energy-estimation model described herein were able to predict a BER value for a complex building in around 0.001-0.1 seconds. This provides a 50x performance increase. For example, an optimisation procedure might require 100,000 iterations. Running the procedure with a SBEM or EnergyPlus simulation engine would take approximately 6 days, assuming a simple building definition that takes only 5 seconds to simulate. In comparison, an optimisation procedure performed as described herein takes less than 3 hours.

As certain examples described herein are able to evaluate hundreds of thousands or millions of potential modifications to a building in a reasonable time, modifications may be suggested that were previously unconsidered. The examples described herein also avoid human bias, which may promote less efficient modifications. This makes it easier to retrofit existing buildings in a manner that minimises disruption (e.g. as modelled using a building operation or utilisation factor) and resource cost. This may allow a significant reduction in greenhouse gas emissions.

Figure 10 shows an example 1000 of a non-transitory computer-readable storage medium 1010 storing instructions 1020 that, when executed by a processor 1030, cause the processor 1030 to perform a series of operations. In one case, the processor 1030 and storage medium 1010 may form part of a system as described in any one of the previous examples. In other cases, the processor 1030 and storage medium 1010 may form part of a different device. The instructions may comprise instructions to implement the method 800 of Figure 8 or the method 900 of Figure 9.

The above examples are to be understood as illustrative of the invention.

Further examples are envisaged. Neural network architectures as described herein may be trained using optimization methods and back-propagation of errors. The non-linear energy-estimation model described herein may be implemented using computer program code that may be automatically differentiated. Computer program code may be written in one or more programming languages, including, but not limited to, C, C++, C#, Python, Java, Fortran, and Perl. Certain configurations may be trained end-to-end, or component-by-component. It is to be understood that any feature described in relation to any one example may be used alone, or in combination with other features described, and may also be used in combination with one or more features of any other of the examples, or any combination of any other of the examples. Furthermore, equivalents and modifications not described above may also be employed without departing from the scope of the invention, which is defined in the accompanying claims.

Claims

CLAIMS1 A system for determining modifications to a building to improve energy use, the system comprising: a mutation engine, implemented by a processor, to receive an original building definition file for the building and to generate one or more mutated building definition files for the building, each building definition file comprising building data representing physical properties of the building, the mutation engine being configured to determine modifications to the building data in the original building definition file to output each mutated building definition file, the modifications representing changes to one or more physical components of the building; a feature generator, implemented by a processor, to receive a building definition file and to generate a feature vector from the building data within the building definition file, the feature vector comprising an array of numeric values, the array having a predefined size, a non-linear energy-estimation model, implemented by a processor, to receive a feature vector generated by the feature generator and to estimate a value for an energy use metric based on the feature vector, the non-linear energy-estimation model being parameterised by a set of trained parameters, the set of trained parameters resulting from a training operation performed using a training data set generated using building definition files associated with a plurality of additional buildings, each sample in the training data set comprising a feature vector corresponding to one of the plurality of additional buildings and a value for the energy use metric; and an optimising controller, implemented by a processor, to control an iterative application of the mutation engine, the feature generator and the non-linear energy-estimation model to determine a modification to the building that improves the energy use metric.
2. The system of claim 1, comprising--an energy estimator, implemented by a processor, to determine a first objective function term based on an energy use metric estimated by the non-linear energy-estimation model; and a resource estimator, implemented by a processor, to determine a second objective function term based on a resource use associated with implementing a difference between a mutated building definition file and the original building definition file, wherein the optimising controller is configured to iteratively optimise an objective function comprising the first and second objective function terms.
3. The system of claim 2, comprising: a building operation estimator, implemented by a processor, to determine a third objective function term based on a change in building utilisation associated with implementing the difference between a mutated building definition file and the original building definition file, wherein the objective function optimised by the optimising controller comprises the first, second and third objective function terms.
4. The system of claim 2 or claim 3, comprising: a user interface to receive desired values for one or more of the objective function terms, wherein the optimising controller is configured to iteratively apply the mutation engine, the feature generator and the non-linear energy-estimation model to determine one or more sets of modifications to physical components of the building that result in the desired values for the one or more objective function terms.
5. The system of any one of claims 2 to 4, wherein the optimising controller is configured to receive a set of constraints for one or more of the objective function terms and to iteratively apply the mutation engine, the feature generator and the non-linear energy-estimation model to determine one or more sets of modifications to physical components of the building that meet the set of constraints
6. The system of any one of claims 1 to 5, wherein the mutation engine is configured to receive a mutation configuration file comprising mutation parameters for one or more properties defined in the building data, each mutation parameter controlling a range and a rate of change for a corresponding property.
7. The system of any one of claims 1 to 6, wherein the building comprises a plurality of areas and, for a given property of the building, the feature generator is configured to generate a numeric input value by determining an area-weighted value from the building data over the plurality of areas as defined in the building data.
8. The system of any one of claims 1 to 7, wherein the feature generator is configured to generate feature vectors comprising arrays of a single fixed size from building definition files having different sizes.
9. The system of any one of claims Ito 8, comprising: a modification database, the modification database comprising a plurality of modification records, each modification record indicating a predefined change in one physical component of the building as represented in building data of a building definition file, wherein the mutation engine is configured to: parse the original building definition file to determine a portion of the original building data associated with one of a plurality of physical components of the building, query the modification database based on the determined portion of the building data; and determine a replacement portion for the portion of the original building data based on results returned from the query, the replacement portion replacing the determined portion in a mutated building definition file.
10. The system of any one of claims I to 9, wherein the non-linear energy-estimation model is a non-linear emulator of a building energy simulator, the building energy simulator being arranged to simulate heat and mass transfer in relation to the building to provide a simulated energy consumption for a building, the data set for the non-linear energy-estimation model being generated from historical data relating to physical buildings, the historical data comprising input data provided to the building energy simulator and a corresponding output generated by the building energy simulator.
11. A method for determining modifications to a building to improve energy use, the method comprising: obtaining original building data representing one or more properties of one or more physical components of the building; determining modifications to the one or more properties to generate modified building data; converting the modified building data to a feature vector, the feature vector comprising an array of numeric values, the array having a predefined size; inputting the feature vector to a non-linear energy estimation model, the non-linear energy estimation model being configured to estimate a value for an energy use metric based on the feature vector, the non-linear energy-estimation predictive model being parameterised by a set of trained parameters, the set of trained parameters resulting from a training operation performed using a training data set generated using building data associated with a plurality of additional buildings, each sample in the training data set comprising a feature vector corresponding to one of the plurality of additional buildings and a value for the energy use metric; and predicting a value for the energy use metric for the modified building data; wherein the method is repeated for a plurality of iterations corresponding to a plurality of modifications, the method further comprising: outputting, based on the plurality of iterations, one or more sets of modifications to the one or more properties of the building that improve the energy use of the building.
12. The method of claim II, wherein optimising comprises: optimising, over the plurality of iterations, an objective function comprising a plurality of terms, the plurality of terms comprising: a first term determined based on the predicted value for the energy use metric, a second term determined based on a resource use associated with implementing a difference between the modified building data and the original building data, and a third term determined based on a change in building utilisation associated with implementing the difference between the modified building data and the original building data.
13. The method of any one of claims 11 to 12, comprising: evaluating whether the predicted value indicates an improvement in the energy use of the building; and determining a further set of modifications to the one or more properties based on the evaluation.
14. The method of any one of claims 11 to 13, comprising: parsing a building definition file for the building to extract the original building data; querying a modification database based on the extracted original building data; receiving a set of results in response to the querying; and determining replacement data for at least a portion of the original building data based on the set of query results, the replacement data replacing the portion of the original building data in a mutated building definition file.
15 The method of any one of claims 11 to 13, wherein converting the modified building data to a feature vector comprises: obtaining definitions of a plurality of areas of the building from the building data, and determining an area-weighted value for at least one modified building property value, the area-weighted value weighting the modified building property value over the plurality of areas.
16. The method of any one of claims 11 to 15, comprising: outputting one or more renovation configurations for the building, each renovation configuration providing an improvement in the energy use metric for the building and comprising one or more changes to the building that provide a corresponding set of modifications to the thermo-physical properties of the building.
17. The method of claim 16, comprising: selecting one of the one or more renovation configurations for the building; and modifying the building to change the thermo-physical properties of the building.
18. A method of training a non-linear energy-estimation model for use in determining modifications to a building to improve energy use, the method comprising: obtaining a data set comprising a plurality of training samples, each training sample comprising a building definition file and an energy use metric for a building, the plurality of training samples comprising building definition files of varying lengths, the energy use metric being assigned by a building energy simulator that simulates energy consumption for the building and that differs from the non-linear energy-estimation model; generating a feature vector for each building definition file, the feature vector being a fixed size and each element in the feature vector being a numerical value haying a predefined range; and training the non-linear energy-estimation model using the feature vector corresponding to each sample as an input and the energy use metric associated with each sample as a ground-truth value to compare with an output of the non-linear energy-estimation model, the training comprising determining values for a set of parameters that characterise the non-linear energy-estimation model.
19. The method of any one of claims 11 to 18, wherein the non-linear energy-estimation model is based on one of the following types of non-linear regression model: gradient-boosted regression trees; artificial neural networks; gaussian process regression and support vector machines
20. A non-transitory computer-readable storage medium storing instructions that, when executed by a processor, cause the processor to perform the method of any one of claims 11 to 19.