====Per Channel Normalisation Formats====

If you want finer-grain control over your normalisation, or you want to be able to take advantage of [[negotiation|negotiation]], you'll want to use a per-channel normalisation format.

These give instructions on how to normalise each of your individual channels. 

A per-channel format includes information for each input channel. They are separated by a colon (:) character and in //output order//.

Each individual channel has the following format....

//Input ID//**>**//Format//

...where the **Input ID** is the name or index of the input, and **Format** is one of the following...

^Format^Meaning^
|A|All inputs are automatically scaled between 0-1, except for those that cross between negative and positive numbers, which are scaled -1 to 1. Values that are always negative are inverted, so the largest negative number is 1 and the smallest 0.|
|-1-1|All inputs are scaled to fit into a scale between -1 and +1|
|0-1|All inputs are scaled to fit in a range between 0-1|
|*|Inputs are **not scaled** and left as raw numbers|
|D|Inputs are **discrete** values rather than continuous. After the D is additional formatting information, shown below|

===Ranges===

You can optionally include the //ranges// with your formatting instructions. These follow an '=' sign, and the minimum and maximum values are separated by a vertical bar (|) character.

For example, if you wanted to auto-scale a value between 0 and 200, you could use the following format - **A=0|200**.

If you want to use your format for [[negotiation|negotiation]], ranges are a helpful addition. 

===Discrete Formats===

If you've used normalisation **D** (discrete), you **must** add range information.

Instead of simply an upper and lower bound, you should enter all the relevant values of the discrete channel, separated by vertical bars (|).

Because discrete values aren't continuous, mapping them to a single analogue input is often going to cause issues.

When mapping a discrete value into an AI, it is instead split into //multiple outputs//, and you'll need to define the outputs you're expecting.

For example, you might have a traffic light that can be in three states - red (0), green (1) and yellow (2). The input in this case is a single channel - [2] when the light is yellow.

If you used the format 'A' on this value, you'd end up getting an output of [1] for yellow, [0.5] for green and [0] for red. Because you have the 'good' value sandwiched between two 'bad' values, AIs might struggle to learn the patterns.

If instead of 'A', you used 'D=0|2|1', the input would be broken up into three distinct outputs - one for 'red', one for 'green' and one for 'blue'. So an input of [2] would result in an output of [0,1,0].