research-article

Multi-donor Neural Transfer Learning for Genetic Programming

Authors:

Alexander Wild,

Barry PorterAuthors Info & Claims

ACM Transactions on Evolutionary Learning, Volume 2, Issue 4

Article No.: 12, Pages 1 - 40

https://doi.org/10.1145/3563043

Published: 24 November 2022 Publication History

Get Access

Abstract

Genetic programming (GP), for the synthesis of brand new programs, continues to demonstrate increasingly capable results towards increasingly complex problems. A key challenge in GP is how to learn from the past so that the successful synthesis of simple programs can feed into more challenging unsolved problems. Transfer Learning (TL) in the literature has yet to demonstrate an automated mechanism to identify existing donor programs with high-utility genetic material for new problems, instead relying on human guidance. In this article we present a transfer learning mechanism for GP which fills this gap: we use a Turing-complete language for synthesis, and demonstrate how a neural network (NN) can be used to guide automated code fragment extraction from previously solved problems for injection into future problems. Using a framework which synthesises code from just 10 input-output examples, we first study NN ability to recognise the presence of code fragments in a larger program, then present an end-to-end system which takes only input-output examples and generates code fragments as it solves easier problems, then deploys selected high-utility fragments to solve harder ones. The use of NN-guided genetic material selection shows significant performance increases, on average doubling the percentage of programs that can be successfully synthesised when tested on two different problem corpora, compared with a non-transfer-learning GP baseline.

Appendices

A Language Operators

Our target programming language uses the operators shown below, and can be automatically translated to C/Java code (Java equivalents are shown for each operator).

B Corpus 1 Problems

C TL Metrics in Detail

In Section 4.4, we reported averaged metrics for TL; here, we report the per-problem metrics for time-to-threshold and transfer ratio, in Tables 12 and 13.

Table 12.

Problem	Generations to threshold	Transfer Ratio
Add	2,388.8	0.89
Append	0.0	0.95
CumulativeAbsoluteSum	2,346.4	1.00
CumulativeSum	2,205.2	0.89
KeepEvenIndices	1,888.8	0.66
ClipToMin	1,932.4	0.70
RetainSecondHalf	0.0	0.93
Sort	2,277.6	0.98
Subtract	1,996.8	0.71
Abs	1,855.2	0.76
GreaterThan	2,362.4	1.39
IndexParity	774.8	0.46
FirstElementOnly	0.0	0.79
Identity	604.4	0.42
DivergentSequence	1,846.8	0.72
Double	1,322.8	0.55
ShiftRight	0.0	0.92
ShiftRightLossy	1,404.0	0.55
ShiftLeft	948.8	0.52
ShiftLeftZeroPadded	1,825.2	0.76
RetainFirstHalf	0.0	0.92
LessThan	2,718.8	1.35
Multiply	1,818.8	0.69
Negative	1,386.8	0.49
Pop	1,257.6	0.49
KeepPositives	1,499.2	0.63
KeepEvens	2,314.4	0.92
ArrayLength	0.0	0.24
ArrayToZero	0.0	0.22
KeepNegatives	1,856.4	0.74
KeepOdds	1,783.6	0.94
Reverse	1,504.8	0.58
CatToSelf	2,111.2	0.81
CatZerosToSelf	2,242.4	0.80
ClipToMax	1,917.2	0.86

Table 12. TL Metrics for 25 Runs of the TL System Compared to the Baseline for the First Corpus

Generations to Threshold represents the average number of generations take for the TL system to outperform the baseline’s asymptotic performance (TL will gain performance after this point). Transfer Ratio is the average fitness of the TL system divided by the average fitness of the baseline (fitnesses less than \(-\)1 set to \(-\)1). (n = 25).

Table 13.

Problem	Generations to threshold	Transfer Ratio
Square	211.0	0.12
HollowSquare	1,060.9	0.27
Parallelogram	1,158.3	0.57
HollowParallelogram	2,129.4	0.87
MirroredParallelogram	1,830.6	0.75
MirroredHollowParallelogram	1,968.1	0.72
RightTriangle	152.0	0.07
HollowRightTriangle	1,003.0	0.18
MirroredRightTriangle	787.5	0.40
HollowMirroredRightTriangle	1,605.4	0.59
InvertedRightTriangle	271.0	0.14
HollowInvertedRightTriangle	2,458.2	0.80
InvertedMirroredRightTriangle	149.0	0.06
Inv’HollowMirr’RightTriangle	792.7	0.24
IsoceleseTriangle	0.0	0.89
HollowIsoceleseTriangle	2,662.2	0.91
InvertedIsoceleseTriangle	1,338.5	0.52
HollowInv’IsoceleseTriangle	1,851.3	0.64
RectangleWithEmptyTrapezoid	2,693.9	1.20
Inv’dRect’WithEmptyTrapezoid	1,952.4	0.95
ObtuseTriangle	1,832.9	0.74
HollowObtuseTriangle	2,556.0	0.96
MirroredObtuseTriangle	465.3	0.48
MirroredHollowObtuseTriangle	2,140.6	0.78
InvertedObtuseTriangle	0.0	0.95
HollowInvertedObtuseTriangle	2,513.9	0.93
InvertedMir’ObtuseTriangle	1,981.7	0.95
HollowMir’Inv’ObtuseTriangle	2,273.9	0.95
VShape	2,022.1	0.63
Trapezoid	561.8	0.45

Table 13. TL Metrics for 25 Runs of the TL System Compared to the Baseline for the Second Corpus

Table 14.

Problem	B’ Success	Success	Fisher Significance
Add	7	17	0.006
Append	28	15	\(1.742*10^{-4}\)
CumulativeAbsoluteSum	1	5	0.090
CumulativeSum	4	14	0.004
KeepEvenIndices	2	23	\(1.705*10^{-8}\)
ClipToMin	2	17	\(2.547*10^{-5}\)
RetainSecondHalf	0	3	0.125
Sort	0	0	1.0
Subtract	5	23	\(2.797*10^{-6}\)
Abs	5	19	\(2.159*10^{-4}\)
GreaterThan	2	5	0.166
IndexParity	22	29	0.011
FirstElementOnly	3	23	\(1.182*10^{-7}\)
Identity	25	30	0.026
DivergentSequence	0	19	\(2.671*10^{-8}\)
Double	4	28	\(1.149*10^{-10}\)
ShiftRight	0	16	\(9.720*10^{-7}\)
ShiftRightLossy	8	28	\(7.062*10^{-8}\)
ShiftLeft	2	24	\(3.695*10^{-9}\)
ShiftLeftZeroPadded	8	24	\(3.350*10^{-5}\)
RetainFirstHalf	0	9	\(9.680*10^{-4}\)
LessThan	0	5	0.026
Multiply	8	22	\(2.896*10^{-4}\)
Negative	15	27	\(6.811*10^{-4}\)
Pop	1	26	\(9.342*10^{-12}\)
KeepPositives	3	27	\(1.393*10^{-10}\)
KeepEvens	0	0	1.0
ArrayLength	25	30	0.026
ArrayToZero	25	30	0.026
KeepNegatives	9	22	\(7.320*10^{-4}\)
KeepOdds	0	1	0.5
Reverse	8	21	\(7.320*10^{-4}\)
CatToSelf	0	21	\(1.791*10^{-9}\)
CatZerosToSelf	2	24	\(3.695*10^{-9}\)
ClipToMax	10	18	0.025

Table 14. Full Breakdown of All Problems in the First Corpus, 1D Arrays, with the Values Shown Being Those Cases Which Passed Generalisation on 1,000 Examples

Fisher significance calculated for these two success rates per problem.

Table 15.

Problem	B’ Success	Success	Fisher Significance
Square	24	30	0.011
HollowSquare	21	30	\(9.680*10^{-4}\)
Parallelogram	0	2	0.25
HollowParallelogram	0	2	0.25
MirroredParallelogram	2	13	\(9.794*10^{-4}\)
MirroredHollowParallelogram	2	6	0.111
RightTriangle	23	30	0.005
HollowRightTriangle	15	30	\(2.916*10^{-6}\)
MirroredRightTriangle	8	30	\(4.135*10^{-10}\)
HollowMirroredRightTriangle	4	27	\(9.721*10^{-10}\)
InvertedRightTriangle	18	30	\(6.181*10^{-5}\)
HollowInvertedRightTriangle	3	24	\(2.739*10^{-8}\)
InvertedMirroredRightTriangle	24	30	0.011
Inv’HollowMirr’RightTriangle	14	30	\(9.720*10^{-7}\)
IsoceleseTriangle	0	2	0.25
HollowIsoceleseTriangle	0	7	0.005
InvertedIsoceleseTriangle	6	24	\(2.981*10^{-6}\)
HollowInv’IsoceleseTriangle	1	15	\(3.110*10^{-5}\)
RectangleWithEmptyTrapezoid	2	2	0.5
Inv’dRect’WithEmptyTrapezoid	0	7	0.005
ObtuseTriangle	0	9	\(9.680*10^{-4}\)
HollowObtuseTriangle	2	16	\(6.839*10^{-5}\)
MirroredObtuseTriangle	0	0	1.0
MirroredHollowObtuseTriangle	0	2	0.25
InvertedObtuseTriangle	0	1	0.5
HollowInvertedObtuseTriangle	0	4	0.058
InvertedMir’ObtuseTriangle	0	3	0.125
HollowMir’Inv’ObtuseTriangle	0	2	0.25
VShape	2	27	\(1.543*10^{-11}\)
Trapezoid	0	2	0.25

Table 15. Full Breakdown of All Problems in the Second Corpus, 2D Arrays, with the Values Shown Being Those Cases Which Passed Generalisation on 1,000 Examples

Fisher significance calculated for these two success rates per problem.

Table 16.

Line	Operator	As Code
1	Literal	variables[6] = 1;
2	Add	variables[7] = variables[0] + variables[6];
3	Make Array	arrays[1] = new int[vars[7]]
4	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
5	Read	variables[5] = arrays[0][variables[2]];
6	Write	arrays[1][variables[2]] = variables[5];
7	Endloop
8	Write	arrays[1][variables[2]] = variables[1];
Fragment	Success Rate
1	3%
\({1,2}\)	27%
\({1,4}\)	10%
4	0%
\({4,5}\)	0%
\({4,6}\)	0%
\({4,8}\)	0%

Table 16. Fragments Assessed from Program “Append”

Program’s code listed, in C-like format, with operators listed ahead of each line for each of readability. Fragments are then described, in reference to lines used followed by success rate using fragment as GP guidance. (n = 30).

Table 17.

Line	Operator	As Code
1	Make Array	arrays[1] = new int[vars[0]]
2	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
3	Literal	variables[5] = –1;
4	Read	variables[3] = arrays[0][variables[2]];
5	Condition	if (variables[3] \(\gt\)0)
6	Else	else
7	Multiply	variables[3] = variables[3] * variables[5];
8	Endloop
9	Add	variables[4] = variables[4] + variables[3];
10	Write	arrays[1][variables[2]] = variables[4];
11	Endloop
Fragment	Success Rate
1	0%
\({1,2}\)	0%
\({1,3}\)	0%
\({1,5}\)	0%
\({1,6}\)	0%
2	0%
\({2,3}\)	0%
\({2,4}\)	3%
\({2,5}\)	3%
\({2,6}\)	0%
3	0%
\({3,5}\)	0%
\({3,6}\)	0%
\({3,7}\)	0%
5	0%
\({5,6}\)	3%
6	0%

Table 17. Fragments Assessed from Program “Cumulative Absolute Sum”

Table 18.

Line	Operator	As Code
1	Literal	variables[4] = 2;
2	Make Array	arrays[1] = new int[vars[0]]
3	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
4	Read	variables[3] = arrays[0][variables[2]];
5	Modulo	variables[5] = variables[3] % variables[4];
6	Condition	if (variables[5]==variables[6])
7	Write	arrays[1][variables[2]] = variables[3];
8	Endloop
9	Endloop
Fragment	Success Rate
1	0%
\({1,2}\)	6%
\({1,3}\)	3%
\({1,5}\)	3%
2	3%
\({2,3}\)	0%
3	0%
\({3,4}\)	0%
\({3,7}\)	0%

Table 18. Fragments Assessed from Program “Keep Evens”

Table 19.

Line	Operator	As Code
1	Literal	variables[6] = 2;
2	Divide	variables[3] = variables[0] / variables[6];
3	Make Array	arrays[1] = new int[vars[3]]
4	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[3];variables[2]++)
5	Read	variables[5] = arrays[0][variables[2]];
6	Write	arrays[1][variables[2]] = variables[5];
7	Endloop
Fragment	Success Rate
1	0%
\({1,2}\)	13%

Table 19. Fragments Assessed from Program “Retain First Half”

Table 20.

Line	Operator	As Code
1	Literal	variables[7] = 2;
2	Make Array	arrays[1] = new int[vars[0]]
3	Loop	for (variables[2]=0;variables[2]<variables[0];variables[2]++)
4	Subtract	variables[6] = variables[0] - variables[2];
5	Subtract	variables[6] = variables[6] - variables[7];
6	Read	variables[5] = arrays[0][variables[6]];
7	Write	arrays[1][variables[2]] = variables[5];
8	Endloop
Fragment	Success Rate
1	63%
\({1,2}\)	80%
\({1,3}\)	77%
2	73%
\({2,3}\)	60%
3	63%
\({3,4}\)	80%
\({3,7}\)	77%

Table 20. Fragments Assessed from Program “Reverse”

Table 21.

Line	Operator	As Code
1	Literal	variables[6] = 1;
2	Add	variables[8] = variables[0] + variables[6];
3	Make Array	arrays[1] = new int[vars[8]]
4	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
5	Add	variables[7] = variables[2] + variables[6];
6	Read	variables[5] = arrays[0][variables[2]];
7	Write	arrays[1][variables[7]] = variables[5];
8	Endloop
Fragment	Success Rate
1	3%
\({1,2}\)	13%
\({1,4}\)	20%
4	0%
\({4,6}\)	0%

Table 21. Fragments Assessed from Program “Shift Right”

Table 22.

Line	Operator	As Code
1	Literal	variables[6] = 2;
2	Add	variables[8] = variables[0] + variables[6];
3	Make Array	arrays[1] = new int[vars[0]]
4	Subtract	variables[9] = variables[0] - variables[6];
5	Loop	for (variables[2]=0;variables[2]<variables[9];variables[2]++)
6	Add	variables[7] = variables[2] + variables[6];
7	Read	variables[5] = arrays[0][variables[2]];
8	Write	arrays[1][variables[7]] = variables[5];
9	Endloop
Fragment	Success Rate
1	80%
\({1,2}\)	73%
\({1,3}\)	63%
\({1,4}\)	63%
3	67%

Table 22. Fragments Assessed from Program “Shift Right Lossy”

Table 23.

Line	Operator	As Code
1	Literal	variables[5] = 1;
2	Subtract	variables[1] = variables[0] - variables[5];
3	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
4	Loop	for (variables[3]=0;variables[3] \(\lt\)variables[1];variables[3]++)
5	Add	variables[6] = variables[3] + variables[5];
6	Read	variables[4] = arrays[0][variables[3]];
7	Read	variables[7] = arrays[0][variables[6]];
8	Subtract	variables[8] = variables[4] - variables[7];
9	Condition	if (variables[8] \(\gt\)0)
10	Write	arrays[0][variables[6]] = variables[4];
11	Write	arrays[0][variables[3]] = variables[7];
12	Endloop
13	Endloop
14	Endloop
15	Make Array	arrays[1] = new int[vars[0]]
16	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
17	Read	variables[5] = arrays[0][variables[2]];
18	Write	arrays[1][variables[2]] = variables[5];
19	Endloop
Fragment	Success Rate
1	0%
\({1,2}\)	0%
\({1,3}\)	0%
\({1,8}\)	0%
\({1,15}\)	0%
\({1,16}\)	0%
3	0%
\({3,8}\)	0%
\({3,15}\)	0%
\({3,16}\)	0%
\({3,17}\)	0%
4	0%
\({4,6}\)	0%
8	0%
\({8,9}\)	0%
\({8,15}\)	0%
\({8,16}\)	0%
15	0%
\({15,16}\)	0%
16	0%

Table 23. Fragments Assessed from Program “Sort”

Table 24.

Line	Operator	As Code
1	Make 2D Array	new 2DArray(size=variables[0]);
2	Literal	variables[6] = 2;
3	Divide	variables[4] = variables[0] / variables[6];
4	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[4];variables[2]++)
5	Loop	for (variables[3]=0;variables[3] \(\lt\)variables[4];variables[3]++)
6	Add	variables[7] = variables[2] + variables[3];
7	Write to 2D	array[variables[7][variables[3]]=1;
8	Endloop
9	Endloop
Fragment	Success Rate
2	23%
\({2,3}\)	30%

Table 24. Fragments Assessed from Program “Mirrored Parallelogram”

Table 25.

Line	Operator	As Code
1	Make 2D Array	new 2DArray(size=variables[0]);
2	Literal	variables[6] = 2;
3	Divide	variables[4] = variables[0] / variables[6];
4	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[4];variables[2]++)
5	Add	variables[5] = variables[2] + variables[4];
6	Write to 2D	array[variables[5][variables[10]]=1;
7	Write to 2D	array[variables[2][variables[4]]=1;
8	Subtract	variables[6] = variables[4] - variables[2];
9	Write to 2D	array[variables[2][variables[6]]=1;
10	Write to 2D	array[variables[5][variables[6]]=1;
11	Endloop
12	Literal	variables[8] = 1;
13	Subtract	variables[7] = variables[0] - variables[8];
14	Write to 2D	array[variables[7][variables[10]]=1;
Fragment	Success Rate
2	13%
\({2,3}\)	60%
\({2,12}\)	10%
12	13%
\({12,13}\)	40%

Table 25. Fragments Assessed from Program “Mirrored Hollow Parallelogram”

Table 26.

Line	Operator	As Code
1	Make 2D Array	new 2DArray(size=variables[0]);
2	Literal	variables[1] = 1;
3	Subtract	variables[4] = variables[0] - variables[1];
4	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
5	Write to 2D	array[variables[2][variables[4]]=1;
6	Write to 2D	array[variables[5][variables[2]]=1;
7	Write to 2D	array[variables[2][variables[2]]=1;
8	Endloop
Fragment	Success Rate
2	80%
\({2,3}\)	90%
\({2,4}\)	80%
4	90%
\({4,6}\)	63%
\({4,7}\)	87%

Table 26. Fragments Assessed from Program “Hollow Right Triangle”

Table 27.

Line	Operator	As Code
1	Make 2D Array	new 2DArray(size=variables[0]);
2	Literal	variables[3] = 1;
3	Subtract	variables[4] = variables[0] - variables[3];
4	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
5	Write to 2D	array[variables[2][variables[4]]=1;
6	Write to 2D	array[variables[4][variables[2]]=1;
7	Subtract	variables[5] = variables[0] - variables[2];
8	Subtract	variables[5] = variables[5] - variables[3];
9	Write to 2D	array[variables[2][variables[5]]=1;
10	Endloop
Fragment	Success Rate
2	67%
\({2,3}\)	93%
\({2,4}\)	80%
4	67%
\({4,7}\)	80%

Table 27. Fragments Assessed from Program “Hollow Mirrored Right Triangle”

Table 28.

Line	Operator	As Code
1	Make 2D Array	new 2DArray(size=variables[0]);
2	Literal	variables[4] = 2;
3	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
4	Multiply	variables[6] = variables[2] * variables[4];
5	Subtract	variables[5] = variables[0] - variables[6];
6	Loop	for (variables[3]=0;variables[3] \(\lt\)variables[5];variables[3]++)
7	Add	variables[7] = variables[3] + variables[2];
8	Write to 2D	array[variables[7][variables[2]]=1;
9	Endloop
10	Endloop
Fragment	Success Rate
2	23%
\({2,3}\)	20%
3	20%

Table 28. Fragments Assessed from Program “Inverted Isosceles Triangle”

Table 29.

Line	Operator	As Code
1	Make 2D Array	new 2DArray(size=variables[0]);
2	Literal	variables[7] = 1;
3	Literal	variables[4] = 2;
4	Divide	variables[5] = variables[0] / variables[4];
5	Loop	for (variables[2]=0;variables[2] \(\lt\)variables[0];variables[2]++)
6	Loop	for (variables[3]=0;variables[3] \(\lt\)variables[5];variables[3]++)
7	Subtract	variables[8] = variables[0] - variables[5];
8	Divide	variables[8] = variables[8] / variables[4];
9	Subtract	variables[8] = variables[8] - variables[3];
10	Add	variables[9] = variables[8] + variables[7];
11	Condition	if (variables[9] \(\gt\)0)
12	Subtract	variables[9] = variables[2] - variables[8];
13	Condition	if (variables[9] \(\gt\)0)
14	Subtract	variables[9] = variables[0] - variables[8];
15	Subtract	variables[9] = variables[9] - variables[2];
16	Condition	if (variables[9] \(\gt\)0)
17	Write to 2D	array[variables[2][variables[3]]=1;
18	Endloop
19	Endloop
20	Endloop
21	Endloop
22	Endloop
Fragment	Success Rate
2	10%
\({2,3}\)	10%
\({2,5}\)	10%
3	3%
\({3,4}\)	0%
\({3,5}\)	10%
5	3%

Table 29. Fragments Assessed from Program “Trapezoid”

D Fisher Significance for Generalised Results

E Full Breakdown of Fragments Evaluated in Baseline GP Fragment Suggestion Experiments

The tables in this section show each fragment evaluated by the exhaustive fragment testing process. Each fragment is at most two lines, and has no variables which depend on being set in lines outside the fragment (therefore, the fragment stands alone in terms of functionality). The source code of the ground-truth implementation is given, firstly as simply the operator used on that line, and secondly in a C-like fashion (excluding braces). This C-like fashion is a programmatically generated translation of the source code of the custom language implementation, provided for ease of readability (due to the difficult-to-parse structure of the custom language). We then refer to the lines in this source code by line number. Fragments cannot contain end-of-block operators (used to indicate the end point of blocks started by the flow-control operators loop and conditional), nor can they contain the initial definition of the 2D canvas.

References

[1]

Qurrat Ul Ain, Harith Al-Sahaf, Bing Xue, and Mengjie Zhang. 2020. A genetic programming approach to feature construction for ensemble learning in skin cancer detection. In Proceedings of the 2020 Genetic and Evolutionary Computation Conference.Association for Computing Machinery, 1186–1194. DOI:DOI:

Abstract

A Language Operators

C TL Metrics in Detail

E Full Breakdown of Fragments Evaluated in Baseline GP Fragment Suggestion Experiments

References

Index Terms

Recommendations

Neural network crossover in genetic algorithms using genetic programming

A Selection Hyper-Heuristic for Transfer Learning in Genetic Programming

Cartesian genetic programming encoded artificial neural networks: a comparison using three benchmarks

Comments

Information

Published In

Publisher

Publication History

Check for updates

Author Tags

Qualifiers

Funding Sources

Contributors

Other Metrics

Bibliometrics

Article Metrics

Other Metrics

Citations

Get Access

Login options

Full Access

View options

PDF

eReader

Full Text

Figures

Other

Share

Share this Publication link

Share on social media

Affiliations