rl-language 0.1.0__tar.gz

rl_language-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include rlc-bin/*
+recursive-include lib *

rl_language-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: rl_language
+Version: 0.1.0
+Author: Massimo Fioravanti
+Author-email: massimo.fioravanti@polimi.it
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Intended Audience :: Developers
+Classifier: Environment :: Console
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: vulture
+Requires-Dist: pytest
+Requires-Dist: pylint
+Requires-Dist: torch
+Requires-Dist: torchviz
+Requires-Dist: numpy
+Requires-Dist: ray[data,serve,train,tune]==2.12.0
+Requires-Dist: hyperopt
+Requires-Dist: gymnasium
+Requires-Dist: dm_tree
+Requires-Dist: typer
+Requires-Dist: scikit-image

rl_language-0.1.0/command_line/__init__.py

@@ -0,0 +1,15 @@
+#
+# This file is part of the RLC project.
+#
+# RLC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation.
+#
+# RLC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with RLC. If not, see <https://www.gnu.org/licenses/>.
+#
+from .utils import (
+    make_rlc_argparse,
+    load_simulation_from_args,
+    load_dataset,
+    load_network,
+)

rl_language-0.1.0/command_line/utils.py

@@ -0,0 +1,93 @@
+#
+# This file is part of the RLC project.
+#
+# RLC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation.
+#
+# RLC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with RLC. If not, see <https://www.gnu.org/licenses/>.
+#
+from shutil import which
+import argparse
+from loader import Simulation, compile
+import pickle
+from ml import RLCTransformer
+import torch
+
+
+def load_network(path, ntokens, device):
+    if path == "":
+        return RLCTransformer(ntokens=ntokens, device=device)
+    return torch.load(path)
+
+
+def load_dataset(path):
+    to_return = []
+    with open(path, "rb") as f:
+        while True:
+            try:
+                loaded = pickle.load(f)
+                for (state, actions_and_scores) in loaded:
+                    to_return.append((state, actions_and_scores))
+            except Exception as e:
+                break
+    return to_return
+
+
+def make_rlc_argparse(name, description):
+    parser = argparse.ArgumentParser(name, description=description)
+    parser.add_argument(
+        "--wrapper",
+        "-w",
+        type=str,
+        nargs="?",
+        help="path to wrapper to load",
+        default="",
+    )
+    parser.add_argument(
+        "--include",
+        "-i",
+        type=str,
+        nargs="*",
+        help="path to folder where rl files can be found",
+        default=[],
+    )
+    parser.add_argument(
+        "--rlc",
+        "-c",
+        type=str,
+        nargs="?",
+        help="path to rlc compiler",
+        default="rlc",
+    )
+    parser.add_argument(
+        "--source",
+        "-rl",
+        type=str,
+        nargs="?",
+        help="path to .rl source file",
+    )
+    parser.add_argument(
+        "--runtime",
+        "-rt",
+        type=str,
+        default="",
+        nargs="?",
+        help="path to runtime library",
+    )
+    return parser
+
+
+def load_simulation_from_args(args):
+    assert (
+        which(args.rlc) is not None
+    ), "could not find executable {}, use --rlc <path_to_rlc> to configure it".format(
+        args.rlc
+    )
+
+    sim = (
+        Simulation(args.wrapper)
+        if args.wrapper != ""
+        else compile(args.source, args.rlc, args.include, args.runtime)
+    )
+    return sim

rl_language-0.1.0/lib/rlc/stdlib/action.rl

@@ -0,0 +1,287 @@
+#
+#Copyright 2024 Massimo Fioravanti
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+#
+
+import collections.vector
+import serialization.to_byte_vector
+import serialization.print
+import bounded_arg
+import math.numeric
+
+trait<FrameType, ActionType> ApplicableTo:
+    fun apply(ActionType action, FrameType frame)
+
+fun<FrameType, ActionType> can_apply_impl(ActionType action, FrameType frame) -> Bool:
+    for alternative of action:
+        using Type = type(alternative)
+        if action is Type:
+            if action is ApplicableTo<FrameType>:
+                return can action.apply(frame)
+    return false
+
+fun<FrameType, ActionType> apply(ActionType action, FrameType frame) { can_apply_impl(action, frame) }: 
+    for alternative of action:
+        using Type = type(alternative)
+        if action is Type:
+            if action is ApplicableTo<FrameType>:
+                action.apply(frame)
+
+
+fun<FrameType, AllActionsVariant> parse_and_execute(FrameType state, AllActionsVariant variant, Vector<Byte> input, Int read_bytes):
+    while read_bytes + 8 <= input.size():
+        if from_byte_vector(variant, input, read_bytes):
+            if can apply(variant, state):
+                apply(variant, state)
+
+fun<AllActionsVariant> parse_actions(AllActionsVariant variant, Vector<Byte> input, Int read_bytes) -> Vector<AllActionsVariant>:
+    let to_return : Vector<AllActionsVariant>
+    while read_bytes + 8 < input.size():
+        if from_byte_vector(variant, input, read_bytes):
+            to_return.append(variant)
+    return to_return
+
+# parses actions taking only one byte and by taking taking the reminder of the parsed number divided by the number of actions, so that no action is ever marked as invalid
+fun<AllActionsVariant> parse_action_optimized(AllActionsVariant variant, Vector<Byte> input, Int read_bytes) -> Bool: 
+    let num_actions : Byte
+    for field of variant:
+        num_actions = num_actions + byte(1)
+
+    let counter : Byte
+    if !from_byte_vector(counter, input, read_bytes):
+        return false
+
+    counter = counter % num_actions
+
+    for field of variant:
+        if counter == byte(0):
+            using Type = type(field)
+            let to_parse : Type
+            if !from_byte_vector(to_parse, input, read_bytes):
+                return false
+            field = to_parse
+            return true
+        counter = counter - byte(1)
+
+    return false
+
+fun<AllActionsVariant> parse_actions(AllActionsVariant variant, Vector<Byte> input) -> Vector<AllActionsVariant>:
+    return parse_actions(variant, input, 0)
+
+fun<FrameType, AllActionsVariant> parse_and_execute(FrameType state, AllActionsVariant variant, Vector<Byte> input):
+    parse_and_execute(state, variant, input, 0)
+
+
+fun<FrameType, AllActionsVariant> gen_python_methods(FrameType state, AllActionsVariant variant):
+    let state : FrameType
+    let serialized = as_byte_vector(state)
+    from_byte_vector(state, serialized)
+    let x : AllActionsVariant
+    apply(x, state)
+    to_string(state)
+    to_string(x)
+    from_string(x, ""s)
+    from_string(state, ""s)
+    parse_actions(x, serialized)
+    from_byte_vector(x, serialized)
+    parse_action_optimized(x, serialized, 0)
+    enumerate(x).size()
+    let v : Vector<Float>
+    to_observation_tensor(state, v)
+    print(variant)
+    v.resize(10)
+    v.size()
+    observation_tensor_size(state)
+
+trait<T> Enumerable:
+    fun enumerate(T obj, Vector<T> output)
+
+fun enumerate(Bool b, Vector<Bool> output):
+    output.append(true)
+    output.append(false)
+
+fun<T> _enumerate_impl(T obj, Int current_argument, Vector<T> out, Int num_args):
+    let counter = 0
+    for field of obj:
+        if counter == current_argument:
+            if field is Enumerable:
+                using Type = type(field)
+                let vec : Vector<Type>
+                field.enumerate(vec)
+
+                let next_current_argument = current_argument + 1
+                let is_last_one = next_current_argument == num_args
+                let counter_2 = 0
+                while counter_2 != vec.size():
+                    field = vec.get(counter_2)
+                    if is_last_one:
+                        out.append(obj)
+                    else:
+                        _enumerate_impl(obj, next_current_argument, out, num_args)
+                    counter_2 = counter_2 + 1
+            return
+        counter = counter + 1
+
+
+fun<T> enumerate(T obj) -> Vector<T>:
+    let to_return : Vector<T>
+    if obj is Enumerable:
+        obj.enumerate(to_return)
+    else if obj is Alternative:
+        for field of obj:
+            using Type = type(field)
+            let field : Type 
+            let alternatives = enumerate(field)
+            let counter = 0
+            while counter < alternatives.size():
+                obj = alternatives.get(counter)
+                to_return.append(obj) 
+                counter = counter + 1
+    else:
+        let num_fields = 0
+        for field of obj:
+            num_fields = num_fields + 1
+        if num_fields == 0:
+            to_return.append(obj)
+            return to_return
+        _enumerate_impl(obj, 0, to_return, num_fields)
+
+    return to_return
+
+trait<T> Tensorable:
+    fun write_in_observation_tensor(T obj, Vector<Float> output, Int counter) 
+    fun size_as_observation_tensor(T obj) -> Int
+
+fun write_in_observation_tensor(Int value, Int min, Int max, Vector<Float> output, Int index):
+    let counter = min
+    while counter < max:
+        if counter == value:
+            output.get(index) = 1.0
+        else:
+            output.get(index) = 0.0
+        index = index + 1
+        counter = counter + 1
+
+
+fun write_in_observation_tensor(Int obj, Vector<Float> output, Int index) :
+    return
+
+fun size_as_observation_tensor(Int obj) -> Int :
+    return 0
+
+fun write_in_observation_tensor(Float obj, Vector<Float> output, Int index) {false}:
+    return
+
+fun size_as_observation_tensor(Float obj) -> Int {false}:
+    return 0
+
+fun write_in_observation_tensor(Bool obj, Vector<Float> output, Int index):
+    if obj:
+        output.get(index) = 1.0
+    else:
+        output.get(index) = 0.0
+    index = index + 1
+
+fun size_as_observation_tensor(Bool obj) -> Int:
+    return 1
+
+fun write_in_observation_tensor(Byte obj, Vector<Float> output, Int index):
+    write_in_observation_tensor(int(obj), -128, 127, output, index)
+
+fun size_as_observation_tensor(Byte obj) -> Int:
+    return 256
+
+fun<T, Int X> write_in_observation_tensor(T[X] obj, Vector<Float> output, Int index):
+    let counter = 0
+    while counter < X:
+        _to_observation_tensor(obj[counter], output, index)
+        counter = counter + 1
+
+fun<T, Int X> size_as_observation_tensor(T[X] obj) -> Int:
+    return _size_as_observation_tensor_impl(obj[0]) * X
+
+fun<T> write_in_observation_tensor(Vector<T> obj, Vector<Float> output, Int index):
+    let counter = 0
+    while counter < obj.size():
+        _to_observation_tensor(obj.get(counter), output, index)
+        counter = counter + 1
+
+fun<T> size_as_observation_tensor(Vector<T> obj) -> Int:
+    return _size_as_observation_tensor_impl(obj.get(0)) * obj.size()
+
+fun<Int min, Int max> write_in_observation_tensor(BInt<min, max> obj, Vector<Float> output, Int index):
+    write_in_observation_tensor(obj.value, min, max, output, index)
+
+fun<Int min, Int max> size_as_observation_tensor(BInt<min, max> obj) -> Int:
+    return max - min 
+
+fun<T> _size_as_observation_tensor_impl(T obj) -> Int:
+    if obj is Tensorable:
+        return obj.size_as_observation_tensor()
+    else if obj is Alternative:
+        let alternative_count = 0
+        for field of obj:
+            alternative_count = alternative_count + 1
+        let max_size = 0
+        for field of obj:
+            using Type = type(field)
+            let fake : Type
+            max_size = max(_size_as_observation_tensor_impl(fake), max_size)
+        return max_size + alternative_count
+    else:
+        let to_return = 0
+        for field of obj:
+            to_return = to_return + _size_as_observation_tensor_impl(field)
+        return to_return
+
+fun<T> _to_observation_tensor(T obj, Vector<Float> output, Int index):
+    if obj is Tensorable:
+        obj.write_in_observation_tensor(output, index)
+        return
+    else if obj is Alternative:
+        let alternative_count = 0
+        for field of obj:
+            alternative_count = alternative_count + 1
+        let current = 0
+        let largest_field = _size_as_observation_tensor_impl(obj) - alternative_count
+        for field of obj:
+            using Type = type(field)
+            if obj is Type:
+                let zeros_to_add = largest_field - _size_as_observation_tensor_impl(obj)
+                write_in_observation_tensor(current, 0, alternative_count, output, index)
+                _to_observation_tensor(field, output, index)
+                while zeros_to_add != 0:
+                    zeros_to_add = zeros_to_add - 1
+                    output.get(index) = 0.0
+                    index = index + 1 
+                return
+            current = current + 1
+    else:
+        for field of obj:
+            _to_observation_tensor(field, output, index)
+
+fun<T> to_observation_tensor(T obj, Vector<Float> output):
+    _to_observation_tensor(obj, output, 0)
+
+fun<T> to_observation_tensor(T obj) -> Vector<Float>:
+    let output : Vector<Float> 
+    let x = _size_as_observation_tensor_impl(obj)
+    while x != 0:
+        x = x - 1
+        output.append(0.0)
+    _to_observation_tensor(obj, output, 0)
+    return output
+
+fun<T> observation_tensor_size(T obj) -> Int:
+    return _size_as_observation_tensor_impl(obj)

rl_language-0.1.0/lib/rlc/stdlib/algorithms/equal.rl

@@ -0,0 +1,29 @@
+trait<T> Comparable
+	fun custom_equal(T lhs, T rhs) -> Bool
+
+fun custom_equal(Int lhs, Int rhs) -> Bool:
+	return lhs == rhs
+
+fun custom_equal(Bool lhs, Bool rhs) -> Bool:
+	return lhs == rhs
+
+fun custom_equal(Byte lhs, Byte rhs) -> Bool:
+	return lhs == rhs
+
+fun custom_equal(Float lhs, Float rhs) -> Bool:
+	return lhs == rhs
+
+fun<T, Int X> custom_equal(T[X] lhs, T[X] rhs):
+	let counter = 0
+	while counter < X:
+		if !(lhs == rhs):
+			return false
+		counter = counter + 1
+	return true
+
+# to implement
+fun<T> equal(T lhs, T rhs):
+	if lhs is Comparable:
+		if rhs is Comparable:
+			return custom_equal(lhs, rhs)
+	for field of lhs

rl_language-0.1.0/lib/rlc/stdlib/bounded_arg.rl

@@ -0,0 +1,143 @@
+# Copyright 2024 Massimo Fioravanti
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import serialization.to_byte_vector
+import string 
+
+ent<Int min, Int max> BInt:
+    Int value
+
+    fun equal(Int other) -> Bool:
+        return self.value == other
+
+    fun equal(BInt<min, max> other) -> Bool:
+        return self.value == other.value
+
+    fun less(BInt<min, max> other) -> Bool:
+        return self.value < other.value
+
+    fun less(Int other) -> Bool:
+        return self.value < other
+
+    fun greater(BInt<min, max> other) -> Bool:
+        return self.value > other.value
+
+    fun greater(Int other) -> Bool:
+        return self.value > other
+
+    fun greater_equal(BInt<min, max> other) -> Bool:
+        return self.value >= other.value
+
+    fun greater_equal(Int other) -> Bool:
+        return self.value >= other
+
+    fun less_equal(BInt<min, max> other) -> Bool:
+        return self.value <= other.value
+
+    fun less_equal(Int other) -> Bool:
+        return self.value <= other
+
+    fun assign(Int other):
+        self.value = other
+        if self.value >= max:
+            self.value = max - 1 
+        if self.value < min:
+            self.value = min 
+
+    fun not_equal(Int other) -> Bool:
+        return self.value != other
+
+    fun not_equal(BInt<min, max> other) -> Bool:
+        return self.value != other.value
+
+    fun add(Int val) -> BInt<min, max>:
+        let other : BInt<min, max>
+        other.value = val
+        return self + other
+
+    fun add(BInt<min, max> other) -> BInt<min, max>:
+        let to_return : BInt<min, max>
+        to_return.value = self.value + other.value
+        if to_return.value >= max:
+            to_return.value = max - 1
+        if to_return.value < min:
+            to_return.value = min
+        return to_return
+
+    fun sub(BInt<min, max> other) -> BInt<min, max>:
+        let to_return : BInt<min, max>
+        to_return.value = self.value - other.value
+        if to_return.value >= max:
+            to_return.value = max - 1
+        if to_return.value < min:
+            to_return.value = min
+        return to_return
+
+    fun sub(Int val) -> BInt<min, max>:
+        let other : BInt<min, max>
+        other.value = val
+        return self - other
+
+
+fun<Int min, Int max> max(BInt<min, max> l, BInt<min, max> r) -> BInt<min, max>:
+  if l < r:
+    return r
+  return l
+
+
+fun<Int min, Int max> min(BInt<min, max> l, BInt<min, max> r) -> BInt<min, max>:
+  if r < l:
+    return r
+  return l
+
+fun<Int min, Int max> append_to_vector(BInt<min, max> to_add, Vector<Byte> output):
+    if max - min < 256:
+        let to_append = byte(to_add.value - min - 128)
+        append_to_vector(to_append, output)
+    else:
+        let to_append = to_add.value - min
+        append_to_vector(to_append, output)
+
+fun<Int min, Int max> parse_from_vector(BInt<min, max> to_add, Vector<Byte> output, Int index) -> Bool:
+    if max - min < 256:
+        let value : Byte 
+        if !parse_from_vector(value, output, index):
+            return false
+        let value_casted = int(value) + 128
+        value_casted = value_casted % (max - min)
+        to_add.value = int(value_casted) + min
+        return true
+    else:
+        let value : Int
+        if !parse_from_vector(value, output, index):
+            return false
+        to_add.value = (value % (max - min)) + min
+        return true
+
+fun<Int min, Int max> append_to_string(BInt<min, max> to_add, String output):
+    append_to_string(to_add.value, output)
+
+fun<Int min, Int max> parse_string(BInt<min, max> to_add, String input, Int index) -> Bool:
+    if !parse_string(to_add.value, input, index):
+        return false
+    if to_add.value < min or to_add.value >= max:
+        return false
+    return true
+
+fun<Int min, Int max> enumerate(BInt<min, max> to_add, Vector<BInt<min, max>> output):
+    let counter = min
+    while counter < max:
+        let x : BInt<min, max>
+        x.value = counter
+        output.append(x)
+        counter = counter + 1