示例#1
0
def getCountFiveProg():
    return PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[
            PPFuncApp(fn=PPVar(name='lib.fold_l'),
                      args=[
                          PPTermUnk(
                              name='nn_fun_x_906',
                              sort=PPFuncSort(args=[
                                  PPTensorSort(param_sort=PPReal(),
                                               shape=[
                                                   PPDimConst(value=1),
                                                   PPDimConst(value=1)
                                               ]),
                                  PPTensorSort(param_sort=PPBool(),
                                               shape=[
                                                   PPDimConst(value=1),
                                                   PPDimConst(value=1)
                                               ])
                              ],
                                              rtpe=PPTensorSort(
                                                  param_sort=PPReal(),
                                                  shape=[
                                                      PPDimConst(value=1),
                                                      PPDimConst(value=1)
                                                  ]))),
                          PPFuncApp(fn=PPVar(name='lib.zeros'),
                                    args=[PPIntConst(value=1)])
                      ]),
            PPFuncApp(fn=PPVar(name='lib.map_l'),
                      args=[PPVar(name='lib.recogFive')])
        ])
示例#2
0
def testCrossover2():
    lib = mkDefaultLib()
    addRecogFive(lib)
    p1 = PPTermUnk(
        name='Unk',
        sort=PPFuncSort(args=[
            PPListSort(param_sort=PPTensorSort(param_sort=PPReal(),
                                               shape=[
                                                   PPDimConst(value=1),
                                                   PPDimConst(value=1),
                                                   PPDimConst(value=28),
                                                   PPDimConst(value=28)
                                               ]))
        ],
                        rtpe=PPTensorSort(
                            param_sort=PPReal(),
                            shape=[PPDimConst(value=1),
                                   PPDimConst(value=1)])))
    p2 = PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[
            PPFuncApp(
                fn=PPVar(name='lib.compose'),
                args=[
                    PPTermUnk(name='Unk',
                              sort=PPFuncSort(args=[PPSortVar(name='B_1')],
                                              rtpe=PPTensorSort(
                                                  param_sort=PPReal(),
                                                  shape=[
                                                      PPDimConst(value=1),
                                                      PPDimConst(value=1)
                                                  ]))),
                    PPTermUnk(name='Unk',
                              sort=PPFuncSort(args=[PPSortVar(name='C')],
                                              rtpe=PPSortVar(name='B_1')))
                ]),
            PPFuncApp(fn=PPVar(name='lib.compose'),
                      args=[
                          PPTermUnk(name='Unk',
                                    sort=PPFuncSort(args=[PPSortVar(name='B')],
                                                    rtpe=PPSortVar(name='C'))),
                          PPTermUnk(name='Unk',
                                    sort=PPFuncSort(args=[
                                        PPListSort(param_sort=PPTensorSort(
                                            param_sort=PPReal(),
                                            shape=[
                                                PPDimConst(value=1),
                                                PPDimConst(value=1),
                                                PPDimConst(value=28),
                                                PPDimConst(value=28)
                                            ]))
                                    ],
                                                    rtpe=PPSortVar(name='B')))
                      ])
        ])
    c1, c2 = crossover(p1, p2, lib)
    assert p1 == c1
    assert p2 == c2
def test_1():
    prog1 = PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[
            PPTermUnk(name='nn_fun_csc4_2',
                      sort=PPFuncSort(
                          args=[PPSortVar(name='B')],
                          rtpe=PPTensorSort(
                              param_sort=PPReal(),
                              shape=[PPDimConst(value=1),
                                     PPDimConst(value=1)]))),
            PPTermUnk(name='nn_fun_csc4_3',
                      sort=PPFuncSort(args=[
                          PPListSort(
                              param_sort=PPTensorSort(param_sort=PPReal(),
                                                      shape=[
                                                          PPDimConst(value=1),
                                                          PPDimConst(value=1),
                                                          PPDimConst(value=28),
                                                          PPDimConst(value=28)
                                                      ]))
                      ],
                                      rtpe=PPSortVar(name='B')))
        ])

    prog2 = PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[
            PPTermUnk(name='nn_fun_csc4_4',
                      sort=PPFuncSort(
                          args=[PPSortVar(name='C')],
                          rtpe=PPTensorSort(
                              param_sort=PPReal(),
                              shape=[PPDimConst(value=1),
                                     PPDimConst(value=1)]))),
            PPTermUnk(name='nn_fun_csc4_5',
                      sort=PPFuncSort(args=[
                          PPListSort(
                              param_sort=PPTensorSort(param_sort=PPReal(),
                                                      shape=[
                                                          PPDimConst(value=1),
                                                          PPDimConst(value=1),
                                                          PPDimConst(value=28),
                                                          PPDimConst(value=28)
                                                      ]))
                      ],
                                      rtpe=PPSortVar(name='C')))
        ])

    prog3 = PPFuncApp(fn=PPVar(name='lib.compose'), args=[prog1, prog2])

    cmts = [PPInt(), PPReal()]
    eprogs = instantiateSortVar(prog3, cmts, 2)
    assert len(eprogs) == 4
    for i, eprog in enumerate(eprogs):
        print(i, ReprUtils.repr_py(eprog))
        print(i, eprog)
        assert not isAbstract(eprog)
示例#4
0
def testMutate0():
    lib = mkDefaultLib()

    # region #+ Add recogFive to library
    inType = mkRealTensorSort([1, 1, 28, 28])
    outType = mkBoolTensorSort([1, 1])
    recogDigitType = mkFuncSort(inType, outType)

    lib.addItem(PPLibItem('recogFive', recogDigitType, None))
    # endregion

    inType = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
    outType = mkListSort(mkBoolTensorSort([1, 1]))
    sort = mkFuncSort(inType, outType)

    prog = PPFuncApp(fn=PPVar(name='lib.map_l'),
                     args=[PPVar(name='lib.recogFive')])

    for i in range(100):
        newProg = mutate(prog, lib)
        if newProg is None:
            continue
        print(repr_py(newProg))

        isort = inferType(newProg, lib)
        assert isort is not None
        assert sort == isort
示例#5
0
def testMutate1():
    lib = mkDefaultLib()

    addRecogFive(lib)

    inType = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
    outType = mkRealTensorSort([1, 1])
    sort = mkFuncSort(inType, outType)

    prog = \
        PPFuncApp(fn=PPVar(name='lib.compose'),
                  args=[PPFuncApp(fn=PPVar(name='lib.fold_l'),
                                  args=[PPTermUnk(name='nn_fun_x_906',
                                                  sort=PPFuncSort(
                                                      args=[PPTensorSort(param_sort=PPReal(),
                                                                         shape=[PPDimConst(value=1),
                                                                                PPDimConst(value=1)]),
                                                            PPTensorSort(param_sort=PPBool(),
                                                                         shape=[PPDimConst(value=1),
                                                                                PPDimConst(value=1)])],
                                                      rtpe=PPTensorSort(param_sort=PPReal(),
                                                                        shape=[PPDimConst(value=1),
                                                                               PPDimConst(value=1)]))),
                                        PPFuncApp(fn=PPVar(name='lib.zeros'), args=[PPIntConst(value=1)])]),
                        PPFuncApp(fn=PPVar(name='lib.map_l'), args=[PPVar(name='lib.recogFive')])])

    for i in range(100):
        newProg = mutate(prog, lib)
        if newProg is None:
            continue
        # print(repr_py(newProg))
        # print('newProg: ', newProg)
        # print('newProgReprPy: ', repr_py(newProg))
        isort = inferType(newProg, lib)
        if isort is None:
            print(repr_py(newProg))
            print('newProg: ', newProg)
            continue

        assert sort == isort
示例#6
0
def testCrossover3():
    lib = mkDefaultLib()
    addRecogFive(lib)
    addRecogFive2(lib)

    countFive1 = \
        PPFuncApp(fn=PPVar(name='lib.compose'),
                  args=[PPFuncApp(fn=PPVar(name='lib.fold_l'),
                                  args=[PPTermUnk(name='nn_fun_x_906',
                                                  sort=PPFuncSort(
                                                      args=[PPTensorSort(param_sort=PPReal(),
                                                                         shape=[PPDimConst(value=1),
                                                                                PPDimConst(value=1)]),
                                                            PPTensorSort(param_sort=PPBool(),
                                                                         shape=[PPDimConst(value=1),
                                                                                PPDimConst(value=1)])],
                                                      rtpe=PPTensorSort(param_sort=PPReal(),
                                                                        shape=[PPDimConst(value=1),
                                                                               PPDimConst(value=1)]))),
                                        PPFuncApp(fn=PPVar(name='lib.zeros'), args=[PPIntConst(value=1)])]),
                        PPFuncApp(fn=PPVar(name='lib.map_l'), args=[PPVar(name='lib.recogFive')])])


    countFive2 = \
        PPFuncApp(fn=PPVar(name='lib.compose'),
                  args=[PPFuncApp(fn=PPVar(name='lib.fold_l'),
                                  args=[PPTermUnk(name='nn_fun_x_906',
                                                  sort=PPFuncSort(
                                                      args=[PPTensorSort(param_sort=PPReal(),
                                                                         shape=[PPDimConst(value=1),
                                                                                PPDimConst(value=1)]),
                                                            PPTensorSort(param_sort=PPBool(),
                                                                         shape=[PPDimConst(value=1),
                                                                                PPDimConst(value=1)])],
                                                      rtpe=PPTensorSort(param_sort=PPReal(),
                                                                        shape=[PPDimConst(value=1),
                                                                               PPDimConst(value=1)]))),
                                        PPFuncApp(fn=PPVar(name='lib.zeros'), args=[PPIntConst(value=1)])]),
                        PPFuncApp(fn=PPVar(name='lib.map_l'), args=[PPVar(name='lib.recogFive2')])])

    c1, c2 = crossover(countFive1, countFive2, lib)
    assert c1 == countFive2
    assert c2 == countFive1
示例#7
0
def testIdTermSortMap2():
    lib = mkDefaultLib()
    addRecogFive(lib)

    prog = PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[
            PPTermUnk(name='Unk',
                      sort=PPFuncSort(
                          args=[
                              PPFuncSort(args=[
                                  PPListSort(param_sort=PPListSort(
                                      param_sort=PPSortVar(name='A_1_2')))
                              ],
                                         rtpe=PPListSort(param_sort=PPListSort(
                                             param_sort=PPSortVar(name='B'))))
                          ],
                          rtpe=PPTensorSort(
                              param_sort=PPReal(),
                              shape=[PPDimConst(value=1),
                                     PPDimConst(value=1)]))),
            PPFuncApp(
                fn=PPVar(name='lib.compose'),
                args=[
                    PPFuncApp(fn=PPVar(name='lib.compose'),
                              args=[
                                  PPVar(name='lib.map_l'),
                                  PPVar(name='lib.map_l')
                              ]),
                    PPTermUnk(
                        name='Unk',
                        sort=PPFuncSort(args=[
                            PPListSort(
                                param_sort=PPTensorSort(param_sort=PPReal(),
                                                        shape=[
                                                            PPDimConst(
                                                                value=1),
                                                            PPDimConst(
                                                                value=1),
                                                            PPDimConst(
                                                                value=28),
                                                            PPDimConst(
                                                                value=28)
                                                        ]))
                        ],
                                        rtpe=PPFuncSort(
                                            args=[PPSortVar(name='A_1_2')],
                                            rtpe=PPSortVar(name='B'))))
                ])
        ])

    m = getIdTermSorts(prog, lib)
    m2 = {
        0: (PPFuncApp(
            fn=PPVar(name='lib.compose'),
            args=[
                PPTermUnk(name='Unk',
                          sort=PPFuncSort(args=[
                              PPFuncSort(args=[
                                  PPListSort(param_sort=PPListSort(
                                      param_sort=PPSortVar(name='A_1_2')))
                              ],
                                         rtpe=PPListSort(param_sort=PPListSort(
                                             param_sort=PPSortVar(name='B'))))
                          ],
                                          rtpe=PPTensorSort(
                                              param_sort=PPReal(),
                                              shape=[
                                                  PPDimConst(value=1),
                                                  PPDimConst(value=1)
                                              ]))),
                PPFuncApp(fn=PPVar(name='lib.compose'),
                          args=[
                              PPFuncApp(fn=PPVar(name='lib.compose'),
                                        args=[
                                            PPVar(name='lib.map_l'),
                                            PPVar(name='lib.map_l')
                                        ]),
                              PPTermUnk(
                                  name='Unk',
                                  sort=PPFuncSort(
                                      args=[
                                          PPListSort(param_sort=PPTensorSort(
                                              param_sort=PPReal(),
                                              shape=[
                                                  PPDimConst(value=1),
                                                  PPDimConst(value=1),
                                                  PPDimConst(value=28),
                                                  PPDimConst(value=28)
                                              ]))
                                      ],
                                      rtpe=PPFuncSort(
                                          args=[PPSortVar(name='A_1_2')],
                                          rtpe=PPSortVar(name='B'))))
                          ])
            ]), None),
        1:
        (PPTermUnk(name='Unk',
                   sort=PPFuncSort(args=[
                       PPFuncSort(args=[
                           PPListSort(param_sort=PPListSort(
                               param_sort=PPSortVar(name='A_1_2')))
                       ],
                                  rtpe=PPListSort(param_sort=PPListSort(
                                      param_sort=PPSortVar(name='B'))))
                   ],
                                   rtpe=PPTensorSort(param_sort=PPReal(),
                                                     shape=[
                                                         PPDimConst(value=1),
                                                         PPDimConst(value=1)
                                                     ]))),
         PPFuncSort(args=[
             PPFuncSort(args=[
                 PPListSort(param_sort=PPListSort(param_sort=PPSortVar(
                     name='A_1_2')))
             ],
                        rtpe=PPListSort(param_sort=PPListSort(
                            param_sort=PPSortVar(name='B'))))
         ],
                    rtpe=PPTensorSort(
                        param_sort=PPReal(),
                        shape=[PPDimConst(value=1),
                               PPDimConst(value=1)]))),
        2: (PPFuncApp(
            fn=PPVar(name='lib.compose'),
            args=[
                PPFuncApp(
                    fn=PPVar(name='lib.compose'),
                    args=[PPVar(name='lib.map_l'),
                          PPVar(name='lib.map_l')]),
                PPTermUnk(
                    name='Unk',
                    sort=PPFuncSort(args=[
                        PPListSort(param_sort=PPTensorSort(param_sort=PPReal(),
                                                           shape=[
                                                               PPDimConst(
                                                                   value=1),
                                                               PPDimConst(
                                                                   value=1),
                                                               PPDimConst(
                                                                   value=28),
                                                               PPDimConst(
                                                                   value=28)
                                                           ]))
                    ],
                                    rtpe=PPFuncSort(
                                        args=[PPSortVar(name='A_1_2')],
                                        rtpe=PPSortVar(name='B'))))
            ]), None),
        3: (PPFuncApp(fn=PPVar(name='lib.compose'),
                      args=[PPVar(name='lib.map_l'),
                            PPVar(name='lib.map_l')]), None),
        4: (PPVar(name='lib.map_l'),
            PPFuncSort(args=[
                PPFuncSort(args=[PPSortVar(name='A')],
                           rtpe=PPSortVar(name='B'))
            ],
                       rtpe=PPFuncSort(
                           args=[PPListSort(param_sort=PPSortVar(name='A'))],
                           rtpe=PPListSort(param_sort=PPSortVar(name='B'))))),
        5: (PPVar(name='lib.map_l'),
            PPFuncSort(args=[
                PPFuncSort(args=[PPSortVar(name='A')],
                           rtpe=PPSortVar(name='B'))
            ],
                       rtpe=PPFuncSort(
                           args=[PPListSort(param_sort=PPSortVar(name='A'))],
                           rtpe=PPListSort(param_sort=PPSortVar(name='B'))))),
        6: (PPTermUnk(
            name='Unk',
            sort=PPFuncSort(args=[
                PPListSort(param_sort=PPTensorSort(param_sort=PPReal(),
                                                   shape=[
                                                       PPDimConst(value=1),
                                                       PPDimConst(value=1),
                                                       PPDimConst(value=28),
                                                       PPDimConst(value=28)
                                                   ]))
            ],
                            rtpe=PPFuncSort(args=[PPSortVar(name='A_1_2')],
                                            rtpe=PPSortVar(name='B')))),
            PPFuncSort(args=[
                PPListSort(param_sort=PPTensorSort(param_sort=PPReal(),
                                                   shape=[
                                                       PPDimConst(value=1),
                                                       PPDimConst(value=1),
                                                       PPDimConst(value=28),
                                                       PPDimConst(value=28)
                                                   ]))
            ],
                       rtpe=PPFuncSort(args=[PPSortVar(name='A_1_2')],
                                       rtpe=PPSortVar(name='B'))))
    }

    assert m == m2
示例#8
0
def testAvoidDimConstUnk():
    term = PPFuncApp(fn=PPVar(name='lib.zeros'),
                     args=[PPTermNT(name='Z', sort=PPDimConst(value=1))])
    ntId = 1
    res = expandToUnk(term, ntId)
    assert res is None
def main():
    # term = PPVar(name='x')
    # print(term)
    # print(doubleVarNames(term))
    # exit()
    # for term in TermsRepo.termsrepo:
    #     print('############')
    #     print(term)
    #     print(doubleVarNames(term))

    prog1 = PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[
            PPTermUnk(name='nn_fun_csc4_2',
                      sort=PPFuncSort(
                          args=[
                              PPSortVar(name='B')],
                          rtpe=PPTensorSort(param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=1)]))),
            PPTermUnk(name='nn_fun_csc4_3',
                      sort=PPFuncSort(
                          args=[PPListSort(param_sort=PPTensorSort(param_sort=PPReal(),
                                                                   shape=[PPDimConst(value=1), PPDimConst(value=1),
                                                                          PPDimConst(value=28),
                                                                          PPDimConst(value=28)]))],
                          rtpe=PPSortVar(name='B')))])

    prog2 = PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[
            PPTermUnk(name='nn_fun_csc4_4',
                      sort=PPFuncSort(
                          args=[
                              PPSortVar(name='C')],
                          rtpe=PPTensorSort(param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=1)]))),
            PPTermUnk(name='nn_fun_csc4_5',
                      sort=PPFuncSort(
                          args=[PPListSort(param_sort=PPTensorSort(param_sort=PPReal(),
                                                                   shape=[PPDimConst(value=1), PPDimConst(value=1),
                                                                          PPDimConst(value=28),
                                                                          PPDimConst(value=28)]))],
                          rtpe=PPSortVar(name='C')))])

    prog3 = PPFuncApp(
        fn=PPVar(name='lib.compose'),
        args=[prog1, prog2])

    prog4 = PPFuncApp(fn=PPVar(name='lib.compose'), args=[PPTermUnk(name='nn_fun_csc4_8', sort=PPFuncSort(
        args=[PPListSort(param_sort=PPSortVar(name='B_1'))],
        rtpe=PPTensorSort(param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=1)]))),
                                                          PPFuncApp(fn=PPVar(name='lib.map_l'), args=[
                                                              PPTermUnk(name='nn_fun_csc4_9', sort=PPFuncSort(args=[
                                                                  PPTensorSort(param_sort=PPReal(),
                                                                               shape=[PPDimConst(value=1),
                                                                                      PPDimConst(value=1),
                                                                                      PPDimConst(value=28),
                                                                                      PPDimConst(value=28)])],
                                                                                                              rtpe=PPSortVar(
                                                                                                                  name='B_1')))])])
    cmts = [PPInt(), PPReal()]
    eprogs = instantiateSortVar(prog4, cmts)
    for i, eprog in enumerate(eprogs):
        print(i, ReprUtils.repr_py(eprog))
        print(i, eprog)