Falken provides developers with a service that allows them to train AI that can play their games

Overview

Falken

Main branch Latest release

NOTE: This is not an officially supported Google product.

Falken provides developers with a service that allows them to train AI that can play their games. Unlike traditional RL frameworks that learn through rewards or batches of offline training, Falken is based on training AI via realtime, human interactions.

Because human time is precious, the system is designed to seamlessly transition between humans playing the game (training) and the AI playing the game (inference). This allows us to support a variety of training styles, from providing a large batch of demonstrations up front to providing “just in time” demonstrations when the AI encounters a state it does not know how to handle.

Behind the scenes, Falken automatically handles logging of experience, separates out human demonstrations, trains new models, serves the best models for on-device inference, and maintains a version history.

Components

This project consists of:

  • A local service that collects experience, trains and serves models.
  • A C++ SDK that can be integrated into C++ games to use the service and an example environment, Hello Falken that demonstrates use of the C++ SDK.
  • A Unity SDK that can be integrated into Unity games to use the service and example environments with Hello Falken being the most simple to get started.
  • A simple web dashboard that connects to the service to provides a way to visualize traces from sessions for debugging purposes.

Getting started

The fastest way to ensure that everything is working properly is to launch a local service then build and run Hello Falken environment.

In C++:

In Unity:

Concepts

Stand up and Initialize Falken

The first step in using Falken is to launch the service and connect to the service from the client SDK (e.g C++ or Unity) using your JSON configuration. All subsequent API calls from the client will automatically use this information.

Define Actions

Actions allow you to define how Falken’s AI interacts with your game and how it learns from humans who play it. In Falken, Actions can be either continuous or discrete.

  • Continuous Actions are used to represent analog controls like a joystick that controls aiming or an analog trigger that controls the gas pedal in a car. All continuous actions are required to include a developer defined min and max value.
  • Discrete Actions can be used to represent simple buttons (like whether the fire button is pressed) or discrete selections (like which weapon to equip). We generally recommend developers create Actions which represent logical interactions (jump, shoot, move, etc) rather than physical inputs (A button, left stick). As such, you may have more Actions in Falken than there are physical inputs for your game.

Define Observations

Observations allow you to define how Falken’s AI perceives your game both while it is playing and while it is “watching” a human play. Falken’s Observations are based on the Entity/Attribute model, where an Entity is simply a container for attributes, each of which have a corresponding name, type, and value.

  • Position: All Entities include an optional, pre-defined 3D position attribute (vector). If used, this position should generally be in world space.
  • Rotation: All Entities include an optional, pre-defined 3D rotation attribute (quaternion). If used, this rotation should generally be in world space.
  • Number: Number attributes represent quantities in the world that can be counted, either as whole numbers (ints) or real numbers (floats). All Number attributes are required to have a developer-defined minimum and maximum value.
  • Category: Categorical attributes represent values with discrete states, like a simple bool or the entries in an enum.
  • Feelers: Feelers represent a set of evenly spaced samples reaching out from an entity. They are commonly used to sense the 3D environment around an entity (usually the player).

Defining the best Observations for your game can be tricky and can impact Falken's performance, so we recommend starting with the bare minimum a human would require to play a game and slowly refining the set of Observations to improve efficacy. In practice we've found that simple observations can yield much better performance.

Create a Brain

In Falken, a Brain represents the idea of the thing that observes, learns, and acts. It’s also helpful to think about each Brain as being designed to accomplish a specific kind of task, like completing a lap in a racing game or defeating enemies while moving through a level in an FPS.

When creating a Brain, you provide a specific set of Actions and a specific set of Observations that define how the brain perceives the world and what actions it can take.

Start a Session. Start an Episode.

In Falken, a Session represents a period of time during which Falken was learning how to play your game, playing your game, or both. Sessions are composed of one or more Episodes, which represent a sequence of interactions with a clear beginning, middle, and end (like starting a race, driving around the track, and crossing the finish line).

Falken supports a number of different Session types, including:

  • Interactive Training: In this mode, Falken learns by watching a human play the game. Players can teach Falken by playing entire Episodes from beginning to end or they can let Falken play and only take over to suggest a correction in behavior whenever Falken makes a mistake.
  • Evaluation: In this mode, Falken plays the game autonomously in order to determine the best model that can be produced for your game given the data provided in earlier Interactive Training mode.
  • Inference: In this mode, Falken simply plays your game as much as you like and intentionally disables all learning features. This guarantees that you get consistent results, and is ideal for testing your game at scale.

All Sessions also require you to define a maximum number of Steps per Episode. You’ll want to set this number to be a comfortable amount more than one a human would require. For example, if you call Episode::Step() every frame, your game runs at 30fps, and a human would take 300 seconds to complete an episode, then you should set a max steps to about 9000 or 12000 to ensure the AI has enough time to complete the task. If the number of steps is too high then Falken will take longer to detect when an agent is stuck when using an evaluation session.

Step the Episode

Every time you want Falken to learn from a human or interact with your game, you need to need to call Step(). Step() always operates on a set of Observations from your game. If a human is playing, then you also provide the Actions that the human performed, and Falken will learn from them. If you want Falken to play your game, don’t pass in any Actions to Step() but instead use the Actions returned by Step() and apply them to your game as if a human had performed them.

For most games, you’ll call Falken’s Step() every time you update your game simulation. However, some games might want to call Step() less often, like when the player takes a turn or performs an important action.

End the Episode. Reset the Game.

Episodes in Falken end when the player succeeds, fails, or the maximum number of steps has been exceeded. You provide this context when you end the Episode.

  • Success: The player (human or AI) has successfully accomplished the goal (e.g. completed a lap or finished the level).
  • Failure: The player (human or AI) failed to accomplish the goal (e.g. car crashed or player was killed by an enemy).
  • Gave Up: The episode reached its max steps without succeeding or failing.
  • Aborted: The episode was unexpectedly terminated in the middle.

Most Sessions involve many Episodes (either for training Falken or testing your game), so when an Episode completes, you’ll need to reset your game state before you bring the next Episode. Falken leaves the definition of this reset up to you and does not require that every Episode in a Session start with identical state. In general, you want each episode to start with similar but not identical state (similar to what many games do for human players) as this helps Falken most effectively learn from and test your game.

Ending one Session. Starting a new Session.

Once you are done with a Session, you simply Stop it. If an Episode is still active when a Session is stopped, the Episode will be Aborted.

When you Stop a learning-type session (InteractiveTraining or Evaluation), the Brain makes a record of what it has learned and "gets smarter". Additional Sessions created with this brain will start from this more intelligent state and use that as the basis for additional learning or playing.

Comments
  • Selected model None for training session

    Selected model None for training session

    I was trying to do run the HelloFalken demo on Unity and after playing 10-20 games letting falken run, the player isn't really moving unless I move it myself.

    I tried checking the dashboard and it did record the episodes where I reached the goal when I was on the recording part of the demo.

    The one thing I found out was that on the falken service cmd it gave this line on each episode

    I1110 17:25:04.257828 34272 model_selector.py:94] Selected model None for training session projects/falken_test/brains/fb5b7334-d6fb-48d9-8ab2-7d8ae98526cc/sessions/0e13a019-4713-4852-baa6-465d2003e806.

    I was trying to figure out how to select a model but am still lost

    opened by nubfight4 11
  • Access Violation Reading Location Error

    Access Violation Reading Location Error

    Hello, decided to open a new issue here since the stuff in the previous one, I was getting all over the place. Anyway, by manually specifying:

        static const char *project_id = "MilleniumFalken";
        static const char* api_key = "somelettersandnumbersandstuff";
    

    I can connect to the service. Now I am getting an exception:

        Exception thrown at 0x00007FFDA32A91A8 (falken_cpp_sdk.dll) in CPPExampleBot.exe: 0xC0000005:
        Access violation reading location 0x0000000000000008.
    

    and the error:

        [Falken] ERROR: CreateBrain failed with status: failed to connect to all addresses.
    

    Thoughts?

    opened by mattlegro 8
  • More of a question...

    More of a question...

    Sorry, I know this isn't really an issue, but not sure where else I might ask such a question. I have a categorical action where a button hold modifies how a joystick input is interpreted, causing the x-axis of the joystick to affect roll instead of yaw. Is all that I need to add this button hold as a categorical action?

    opened by mattlegro 7
  • Problem using falken::ObservationsBase

    Problem using falken::ObservationsBase

    Hello again, So this is a bit of a complicated one. To get into the background of what I'm doing, I'm trying to integrate falken with Rocket League. This is not a game I made, however, there are two communities that have discovered ways to access the game files that have since been officially sanctioned by Psyonix, Rocket League's producer. One of them is a botting community, for making AI that play each other (no cheating or abusing the system of course).

    Now, I realized that they have structures to access all of the information that might be useful to the learner service. However, I am having a weird issue that I can't figure out, so if you can provide any ideas at all I would appreciate it.

    So, I am writing a cpp bot. I am using dynamic assignment as in the falken_player_dynamic example.

    If I comment out everything referencing falken:: in my bot.cc file, it runs fine with the rest of the code, even with some falken pointers being created in the bot.h file. If I uncomment the first line making a reference falken::ObservationsBase observations; in bot.cc I get an error. The error it gives is "Could not connect to server!" Which is thrown in this function called in their code. The framework is written in python but handles cpp bots.

        def run_independently(self, terminate_request_event):
            while not terminate_request_event.is_set():
                message = f"add\n{self.name}\n{self.team}\n{self.index}\n{game_interface.get_dll_directory()}"
                try:
                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    s.connect(("127.0.0.1", self.port))
                    s.send(bytes(message, "ASCII"))
                    s.close()
                except ConnectionRefusedError:
                    self.logger.warn("Could not connect to server!")
    
                time.sleep(1)
            else:
                self.retire()
    

    So, doing some tracing, I find that ConnectionRefusedError is class ConnectionRefusedError(ConnectionError): ... where ConnectionError is class ConnectionError(OSError): ... and finally

    class OSError(Exception):
        errno: int
        strerror: str
        # filename, filename2 are actually str | bytes | None
        filename: Any
        filename2: Any
        if sys.platform == "win32":
            winerror: int
    
    EnvironmentError = OSError
    IOError = OSError
    if sys.platform == "win32":
        WindowsError = OSError
    

    Getting any deeper into Exception you just get to a base exception class which seems built to parse system errors. This leads me to believe that any underlying Environment, OS, or IO errors would lead to their framework throwing 'Could not connect to server." I have no idea if this interpretation is real but can you imagine anything that would cause OS or IO type errors just by adding the line falken::ObservationsBase observations;? If there is any questions I can answer let me know, and if this is really beyond your purview of questions you want to answer, no worries.

    opened by mattlegro 6
  • Error with loading old brain in HelloFalkenDynamic

    Error with loading old brain in HelloFalkenDynamic

    Hi,

    So I was experimenting with reloading brains to continue training from a specific snapshot. I was having troubles in my program, so I went back to HelloFalken to make sure I was doing it properly. With the static HelloFalken.exe, I have no problem passing -brain_id and -snapshot_id. However, when I try to use HelloFalkenDynamic.exe, I get the following output:

    > .\Release\HelloFalkenDynamic.exe -brain_id f08db37f-c99b-4b73-b60b-5d87ca9904f8 -snapshot_id a9f42bf5-6619-408e-9abc-2354bcce43fa
    INFO: Starting game with brain_id f08db37f-c99b-4b73-b60b-5d87ca9904f8 and snapshot_id a9f42bf5-6619-408e-9abc-2354bcce43fa
    INFO: Connected to Falken!
    INFO: Created brain: f08db37f-c99b-4b73-b60b-5d87ca9904f8
    INFO: Started session: eff1ac11-c995-4887-b629-a69e227821d7
    [Falken] ERROR: Entity goal not found in container. Found [entity_0, player, ]
    

    The brain was originally created through running .\Release\HelloFalkenDynamic.exe without passing brain_id or snapshot_id flags. I find that I can use the same brain and snapshot IDs when running the static example and don't have any problems, only in the dynamic example.

    It is as if the 'goal' entity is not rebound properly. Thoughts?

    opened by mattlegro 4
  • Stuck at installation

    Stuck at installation

    Hi , Can anyone help me with the setup installation in falken unity sdk in windows I am done with the prerequests

    Python is installed (version is the latest) Pip pakage installer is installed openssl is installed (all system variables are set )

    And i downloaded the falken unity sdk from the relase page and extracted to my drive

    Issue When following the instructions at Launcher - intructions

    I am unclear about the steps ... when running : Run the following command at the root of the falken repo: python service/launcher.py --project_ids falken_test

    My system says that there is no directory or file called laucher.py

    Can someone help me with the rest of the installation as I am hoping to use falken with unity

    Thanks

    opened by Ronith-liyanage 3
  • Unable to use the Function falken::Rotation.FromEulerAngles(float roll, float pitch, float yaw)

    Unable to use the Function falken::Rotation.FromEulerAngles(float roll, float pitch, float yaw)

    Hello Auther, I am trying to use the tool to learn robot navigation where I have written a game wrapper to interact with the falken in C++.

    I am trying to use thefallen::Roationclass to set the rotation and then use this instance to set the entity rotation as follows.

    falken::Rotation entity_rotation; 
    entity_roation.FromEulerAngles(roll, pitch,yaw);
    brain_spec.observations.rotation.set_rotation(entity_rotation);
    

    Upon building my game wrapper CMake gives me the following error.

    error

    I ran the following sanity checks to make sure that I am linking the Falken right.

    1. Including the Falken directory that has Findfalken.cmake into the CMAKE_MODULE_PATH

      list(APPEND CMAKE_MODULE_PATH /home/sandip.patel/teleop_game/src/game_engine/falken_cpp_sdk)

    2. Find Falken with find package in the CMakeList find_package(falken REQUIRED)

    3. Linking the Falken with executable: target_link_libraries(listener_mutex falken_cpp_sdk)

    I even checked if the Falken is linked correctly by checking if Falken shared object library is linked or not.

    libfalken_cpp_sdk.so =>/home/sandip.patel/teleop_game/src/game_engine/falken_cpp_sdk/lib/Linux/Release/libfalken_cpp_sdk.so (0x00007f6156323000)

    So, everything seems fine to me. Am I missing anything that leads to this error of undefined reference in the above image?

    Thanks!

    opened by sandip1604 3
  • configure network environment falken service

    configure network environment falken service

    Hi,

    I would like to configure Falken Service on an independent server with it own ip instead of localhost. Do I just change the IP address in the service json file only? how bout the environment key in the json that currently only show "local" is there any other value that i can use?. tried looking into the generate sdk config file, but there is only local config (_LOCAL_CONNECTION_CONFIG)

    opened by MoSyazwan 2
  • _lockfile.py:385 timed out

    _lockfile.py:385 timed out

    Sometimes I get this error when re-open Falken after it was closed on my powershell console by pressing ctrl-c or just closing the window.

    Is there a good way to shut it down or a reason behind this error?

    image

    opened by Jurys22 2
  • Falken coordinate system assumptions

    Falken coordinate system assumptions

    Hi,

    I'm trying to get falken to work in Unreal Engine but I'm having a hard time to get the desired results. I suspect this may have to do with UE4 uses a Z up left hand coordinate system, as opposed to the Y up one assumed by falken. I also noticed that the hello falken project has some special treatment for the 2D angle when converting it to quaternion, quote:

    // Falken uses 3D coordinates. We therefore interpret game 2D locations as
    // 3D positions on the XZ plane. We translate a HelloFalken angle into a
    // quaternion that specifies a rotation around the Y-axis. We need to
    // modify the angle in two ways before constructing the quaternion:
    // 1) We need to offset the angle by 90 degrees. This is because Falken
    //    assumes that an object at neutral orientation points towards the
    //    Z-axis, but an object at neutral orientation in HelloFalken points
    //    towards the X-axis.
    // 2) Falken uses a left-handed coordinate system, so rotations around the
    //    Y-axis are clockwise (when looking at the XZ plane from above). Since
    //    angles in HelloFalken are counter-clockwise, we need to negate the
    //    angle.
    

    I'm mostly curious why falken has such a limitation/assumption of the "default" coordinate system used. Which part of the code base relies on such assumption to work?

    Thanks!

    opened by haowang1013 2
  • Coordinate System Confusion

    Coordinate System Confusion

    Hey,

    So I'm having problems getting my brains to learn, and I am trying to double check if I am feeding falken position and location information properly. Based on this thread and the quoted comment from math_utils.h in hellofalken:

      // Falken uses 3D coordinates. We therefore interpret game 2D locations as
      // 3D positions on the XZ plane. We translate a HelloFalken angle into a
      // quaternion that specifies a rotation around the Y-axis. We need to
      // modify the angle in two ways before constructing the quaternion:
      // 1) We need to offset the angle by 90 degrees. This is because Falken
      //    assumes that an object at neutral orientation points towards the
      //    Z-axis, but an object at neutral orientation in HelloFalken points
      //    towards the X-axis.
      // 2) Falken uses a left-handed coordinate system, so rotations around the
      //    Y-axis are clockwise (when looking at the XZ plane from above). Since
      //    angles in HelloFalken are counter-clockwise, we need to negate the
      //    angle.
    

    the falken service expects a left-handed axis with +y pointing out of the page, making +z downward while +x is to the left. My program uses a left-handed coordinate system with +z pointing out of the page, +y pointing up and +x pointing left. So to convert positions between the two seems simple, where I need to make an (x,y,z) in my program (x,z,-y) when I feed it to falken. The rotation thing is a bit more involved however, but I have the pitch, yaw, and roll for my player as defined relative to my axes, and since it is a left handed axis system where positive rotations around the out of the page axis increases in the clockwise direction, as expected by falken, I think converting these to a quaternion to feed to falken should work.

    The use case is pretty simple, right now I am just trying to train an agent to steer toward a target, basically a reimplementation of HelloFalken in my program, but it keeps crashing on passing control to the brain because the brain isn't able to learn and outputs nans.

    Am I missing something?

    opened by mattlegro 1
  • Build failure

    Build failure

    Hi, I followed the instruction and the service is waiting for assignment. I tried to build the hello falken example but it failed because I didn't have a nasm compiler Luckily I found a stack overflow answer that helped me: https://stackoverflow.com/questions/73214824/missing-cmake-asm-nasm-compiler-when-compiling-grpc-with-ms-visual-studio I kindly suggest you add this compiler/.exe/whatever as a prerequisite alongside OpenSSL and python Unless I installed the wrong version of OpenSSL that should've shipped this :/

    Thanks and sorry to bother you!

    opened by MasterDrake 0
  • anyone having same issue where the agent not able to connect to the falken service?

    anyone having same issue where the agent not able to connect to the falken service?

    it shows error, failed to connect to all addresses.

    a couple of months ago it works fine. until today i was about to run back the falken, i got this error, tried on multple pc still getting the same result. suspect is the windows update causing this.

    opened by MoSyazwan 4
  • Training status

    Training status

    Hello Falken Team,

    I am using falken and wrote a Game wrapper to feed the recorded episodes into the falken and was hoping to Find a way on deciding at the indicator on when to close the session based on weather the training for the session is over or not. Is there a variable embedded in the session/brain class that show weather the training is complete or not?

    I used the following condition to check weather its safe to close the session or not:

    (m_session->training_state() == falken::Session::TrainingState::kTrainingStateComplete

    where m_session is the pointer to the session object. Even though I see the service is done training and prints

    I0120 18:50:37.445522 139731869705152 learner.py:106] Waiting for assignment.

    the above condition does not evaluate to true

    opened by sandip1604 0
  • letting the snapshot Id null will throw up error

    letting the snapshot Id null will throw up error

    as per stated in code, you can leave snapshot id null so that it will use any latest snapshot to load the brain. Im getting error when put null for the snapshot. image

    opened by MoSyazwan 1
  • CreateBrainInternal ( ) returning invalid brain_id on Unreal Engine but able to log and see the created brain id log on python service

    CreateBrainInternal ( ) returning invalid brain_id on Unreal Engine but able to log and see the created brain id log on python service

    Hey, So this happens after I have established my service using the C++ SDK with Unreal Engine. When i am creating the brain using CreateBrain(BrainName.c_str()); which in turn invokes CreateBrainInternal() I get a random string as the brain_id and hence when I try to StartSession(). The python service throws the following error

    [libprotobuf ERROR T:\src\github\protobuf\protobuf\src\google\protobuf\wire_format_lite.cc:581] String field 'falken.proto.SessionSpec.brain_id' contains invalid UTF-8 data when parsing a protocol buffer. Use the 'bytes' type if you intend to send raw bytes. E0114 15:35:11.568410 29492 _common.py:88] Exception deserializing message! Traceback (most recent call last): File "C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\grpc\_common.py", line 86, in _transform return transformer(message) google.protobuf.message.DecodeError: Error parsing message with type 'falken.proto.CreateSessionRequest'

    I have checked my python as well as protobuf dependencies and they seem fine. P.S. The fun part is the example project HelloFalken works fine using the same SDK and dependencies

    Unreal Engine 4.27.1 Visual Studio 2019 C++ sdk (0.0.2) Python 3.9.9 protobuf :3.19.3

    opened by badAcc3ss 1
  • session type Evaluation mode throw error

    session type Evaluation mode throw error

    I try to run using Evaluation mode (Falken.Session.Type.Evaluation), however it show error. brain ID and snapshot ID already added.

    Failed to create a new session for brain Hello Falken Brain (23d14e02-ba6b-4c01-aabe-76d69016bd4b): Error message: Session type 3 requires a starting snapshot for brain 23d14e02-ba6b-4c01-aabe-76d69016bd4b.. Error code: 2. If the error persists, please contact Falken for further assistance..
    UnityEngine.Debug:LogError(Object)
    Falken.Logger:LogMessage(LogLevel, String, IntPtr) (at Assets/Falken/Scripts/Log.cs:164)
    FalkenInternal.falken_modulePINVOKE:falken_BrainBase_StartSession(HandleRef, Int32, UInt32)
    FalkenInternal.falken.BrainBase:StartSession(Type, UInt32) (at Assets/Falken/Scripts/Gen/falken/BrainBase.cs:94)
    Falken.BrainBase:StartSession(Type, UInt32) (at Assets/Falken/Scripts/Brain.cs:202)
    BasePlayer:CreateOrLoadBrain() (at Assets/Scripts/Entity/Player/BasePlayer-Falken.cs:281)
    BasePlayer:OnEnable() (at Assets/Scripts/Entity/Player/BasePlayer-Falken.cs:178)
    UnityEngine.GameObject:SetActive(Boolean)
    PoolableEx:AwakeFromInstantiate(GameObject) (at Assets/Scripts/Util/Memory/Poolable.cs:412)
    Client:CreateOrUpdateEntity(Entity, Int64, Boolean) (at Assets/Scripts/Client/Client.EntityNetworking.cs:1229)
    Client:OnEntities(Message) (at Assets/Scripts/Client/Client.EntityNetworking.cs:1072)
    Client:OnNetworkMessage(Message) (at Assets/Scripts/Client/Client.Connection.cs:327)
    Facepunch.Network.DTLS.Client:HandleMessage() (at Assets/Plugins/D11.DTLS/DTLS.Client.cs:146)
    Facepunch.Network.DTLS.Client:OnMessageReceived(Byte[], Int32, String, Int32) (at Assets/Plugins/D11.DTLS/DTLS.Client.cs:305)
    D11.DTLSConnection:ProcessRecvBuffer() (at Assets/Plugins/D11.DTLS/Connection.cs:114)
    D11.DTLS:ProcessConnections() (at Assets/Plugins/D11.DTLS/DTLS.cs:840)
    D11.DTLS:Update() (at Assets/Plugins/D11.DTLS/DTLS.cs:610)
    
     System.InvalidOperationException: Session in brain 'Hello Falken Brain' with id '23d14e02-ba6b-4c01-aabe-76d69016bd4b' could not be created. Possible reasons are:
    1. Service got cleaned up before this brain.
    2. Given session type ('Evaluation') is 'Invalid'
    3. An error ocurred in the service.
      at Falken.BrainBase.StartSession (Falken.Session+Type type, System.UInt32 maxStepsPerEpisode) [0x0001d] in C:\Repos\rust_console_win64\Assets\Falken\Scripts\Brain.cs:206 
      at BasePlayer.CreateOrLoadBrain () [0x0006a] in C:\Repos\rust_console_win64\Assets\Scripts\Entity\Player\BasePlayer-Falken.cs:281 
    UnityEngine.Debug:LogError(Object)
    BasePlayer:CreateOrLoadBrain() (at Assets/Scripts/Entity/Player/BasePlayer-Falken.cs:286)
    BasePlayer:OnEnable() (at Assets/Scripts/Entity/Player/BasePlayer-Falken.cs:178)
    UnityEngine.GameObject:SetActive(Boolean)
    PoolableEx:AwakeFromInstantiate(GameObject) (at Assets/Scripts/Util/Memory/Poolable.cs:412)
    Client:CreateOrUpdateEntity(Entity, Int64, Boolean) (at Assets/Scripts/Client/Client.EntityNetworking.cs:1229)
    Client:OnEntities(Message) (at Assets/Scripts/Client/Client.EntityNetworking.cs:1072)
    Client:OnNetworkMessage(Message) (at Assets/Scripts/Client/Client.Connection.cs:327)
    Facepunch.Network.DTLS.Client:HandleMessage() (at Assets/Plugins/D11.DTLS/DTLS.Client.cs:146)
    Facepunch.Network.DTLS.Client:OnMessageReceived(Byte[], Int32, String, Int32) (at Assets/Plugins/D11.DTLS/DTLS.Client.cs:305)
    D11.DTLSConnection:ProcessRecvBuffer() (at Assets/Plugins/D11.DTLS/Connection.cs:114)
    D11.DTLS:ProcessConnections() (at Assets/Plugins/D11.DTLS/DTLS.cs:840)
    D11.DTLS:Update() (at Assets/Plugins/D11.DTLS/DTLS.cs:610)
    
    opened by MoSyazwan 1
Releases(0.0.2)
Owner
Google Research
Google Research
Model Validation Toolkit is a collection of tools to assist with validating machine learning models prior to deploying them to production and monitoring them after deployment to production.

Model Validation Toolkit is a collection of tools to assist with validating machine learning models prior to deploying them to production and monitoring them after deployment to production.

FINRA 25 Dec 28, 2022
inding a method to objectively quantify skill versus chance in games, using reinforcement learning

Skill-vs-chance-games-analysis - Finding a method to objectively quantify skill versus chance in games, using reinforcement learning

Marcus Chiam 4 Nov 19, 2022
Used Logistic Regression, Random Forest, and XGBoost to predict the outcome of Search & Destroy games from the Call of Duty World League for the 2018 and 2019 seasons.

Call of Duty World League: Search & Destroy Outcome Predictions Growing up as an avid Call of Duty player, I was always curious about what factors led

Brett Vogelsang 2 Jan 18, 2022
Decentralized deep learning in PyTorch. Built to train models on thousands of volunteers across the world.

Hivemind: decentralized deep learning in PyTorch Hivemind is a PyTorch library to train large neural networks across the Internet. Its intended usage

null 1.3k Jan 8, 2023
A Tools that help Data Scientists and ML engineers train and deploy ML models.

Domino Research This repo contains projects under active development by the Domino R&D team. We build tools that help Data Scientists and ML engineers

Domino Data Lab 73 Oct 17, 2022
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models.

Tangram Website | Discord Tangram makes it easy for programmers to train, deploy, and monitor machine learning models. Run tangram train to train a mo

Tangram 1.4k Jan 5, 2023
Production Grade Machine Learning Service

This project is made to help you scale from a basic Machine Learning project for research purposes to a production grade Machine Learning web service

Abdullah Zaiter 10 Apr 4, 2022
machine learning model deployment project of Iris classification model in a minimal UI using flask web framework and deployed it in Azure cloud using Azure app service

This is a machine learning model deployment project of Iris classification model in a minimal UI using flask web framework and deployed it in Azure cloud using Azure app service. We initially made this project as a requirement for an internship at Indian Servers. We are now making it open to contribution.

Krishna Priyatham Potluri 73 Dec 1, 2022
ELI5 is a Python package which helps to debug machine learning classifiers and explain their predictions

A library for debugging/inspecting machine learning classifiers and explaining their predictions

null 154 Dec 17, 2022
MosaicML Composer contains a library of methods, and ways to compose them together for more efficient ML training

MosaicML Composer MosaicML Composer contains a library of methods, and ways to compose them together for more efficient ML training. We aim to ease th

MosaicML 2.8k Jan 6, 2023
Given the names and grades for each student in a class N of students, store them in a nested list and print the name(s) of any student(s) having the second lowest grade.

Hackerank-Nested-List Given the names and grades for each student in a class N of students, store them in a nested list and print the name(s) of any s

Sangeeth Mathew John 2 Dec 14, 2021
Retrieve annotated intron sequences and classify them as minor (U12-type) or major (U2-type)

(intron I nterrogator and C lassifier) intronIC is a program that can be used to classify intron sequences as minor (U12-type) or major (U2-type), usi

Graham Larue 4 Jul 26, 2022
An open source framework that provides a simple, universal API for building distributed applications. Ray is packaged with RLlib, a scalable reinforcement learning library, and Tune, a scalable hyperparameter tuning library.

Ray provides a simple, universal API for building distributed applications. Ray is packaged with the following libraries for accelerating machine lear

null 23.3k Dec 31, 2022
A Python Module That Uses ANN To Predict A Stocks Price And Also Provides Accurate Technical Analysis With Many High Potential Implementations!

Stox A Module to predict the "close price" for the next day and give "technical analysis". It uses a Neural Network and the LSTM algorithm to predict

Stox 31 Dec 16, 2022
Meerkat provides fast and flexible data structures for working with complex machine learning datasets.

Meerkat makes it easier for ML practitioners to interact with high-dimensional, multi-modal data. It provides simple abstractions for data inspection, model evaluation and model training supported by efficient and robust IO under the hood.

Robustness Gym 115 Dec 12, 2022
Pandas-method-chaining is a plugin for flake8 that provides method chaining linting for pandas code

pandas-method-chaining pandas-method-chaining is a plugin for flake8 that provides method chaining linting for pandas code. It is a fork from pandas-v

Francis 5 May 14, 2022
STUMPY is a powerful and scalable Python library for computing a Matrix Profile, which can be used for a variety of time series data mining tasks

STUMPY STUMPY is a powerful and scalable library that efficiently computes something called the matrix profile, which can be used for a variety of tim

TD Ameritrade 2.5k Jan 6, 2023
Uber Open Source 1.6k Dec 31, 2022
Can a machine learning project be implemented to estimate the salaries of baseball players whose salary information and career statistics for 1986 are shared?

END TO END MACHINE LEARNING PROJECT ON HITTERS DATASET Can a machine learning project be implemented to estimate the salaries of baseball players whos

Pinar Oner 7 Dec 18, 2021