agent.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a94145-25e8-4c1e-aa84-47ffe81a8c99",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy\n",
    "import sys\n",
    "import torch\n",
    "from agent import NeuralSGDAgent, SplitNeuralSGDAgent\n",
    "\n",
    "print(\"===VERSIONS===\")\n",
    "print(f\"Python: {sys.version}\")\n",
    "print(f\"numpy: {np.__version__}\")\n",
    "print(f\"PyTorch: {torch.__version__}\")\n",
    "print(f\"Scipy: {scipy.__version__}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "365867da-1b1d-403f-9ce3-b7b67ed5ad79",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from pythonosc.dispatcher import Dispatcher\n",
    "from pythonosc.osc_server import BlockingOSCUDPServer\n",
    "from pythonosc.udp_client import SimpleUDPClient\n",
    "from threading import Event, Thread\n",
    "import time\n",
    "\n",
    "manualMode = True\n",
    "agents = {}\n",
    "\n",
    "agentType = \"joint\"\n",
    "haptic_dims = 6\n",
    "\n",
    "ip = \"127.0.0.1\" # localhost\n",
    "port = 8080\n",
    "destPort = 8081\n",
    "\n",
    "client = SimpleUDPClient(ip, destPort)\n",
    "timings = []\n",
    "\n",
    "def default_handler(address, *args):\n",
    "    print(f\"DEFAULT {address}: {args}\")\n",
    "\n",
    "def auto_switch_handler(_, state: bool, *args):\n",
    "    start_time = time.time()\n",
    "    print(f\"Is Manual {state}\")\n",
    "    manualMode = state\n",
    "    end_time = time.time()\n",
    "    timings.append({\"key\": \"switch\", \"start\": start_time, \"end\": end_time})\n",
    "\n",
    "# This one actually runs on changes\n",
    "def manual_set(_, element: int, *args: float):\n",
    "    start_time = time.time()\n",
    "    state = args[::3]\n",
    "    low = args[1::3]\n",
    "    high = args[2::3]\n",
    "    agents[element].set_state(state=state, lows=low, highs=high, history=True)\n",
    "    end_time = time.time()\n",
    "    timings.append({\"key\": \"manual_set\", \"start\": start_time, \"end\": end_time})\n",
    "    #print(f\"{element}: {agents[element].state}\")\n",
    "\n",
    "def manual_update(_, element: int, *args: float):\n",
    "    start_time = time.time()\n",
    "    state = args[::3]\n",
    "    low = args[1::3]\n",
    "    high = args[2::3]\n",
    "    agents[element].set_state(state=state, lows=low, highs=high, history=False)\n",
    "    end_time = time.time()\n",
    "    timings.append({\"key\": \"manual_update\", \"start\": start_time, \"end\": end_time})\n",
    "\n",
    "def jump_unexplored(address, element: int):\n",
    "    start_time = time.time()\n",
    "    new_state = agents[element].select_less_explored()\n",
    "    agents[element].set_state(state=new_state, history=True)\n",
    "    # auto jump\n",
    "    step(address, element)\n",
    "\n",
    "def step(_, element: int):\n",
    "    start_time = time.time()\n",
    "    old_state = agents[element].state\n",
    "    action = agents[element].select_epsilon_greedy_action()\n",
    "    if action is not None:\n",
    "        #print(f\"{element}: Taking action {action}\")\n",
    "        agents[element].apply_action(action)\n",
    "        #print(f\"Transitioned from {old_state} to {agent.state}\")\n",
    "        client.send_message(\"/controller/agentSet\", [element, *agents[element].state])\n",
    "        agents[element].replay_from_history()\n",
    "    else:\n",
    "        print(f\"{element}: All actions excluded! Doing nothing.\")\n",
    "    end_time = time.time()\n",
    "    timings.append({\"key\": \"step\", \"start\": start_time, \"end\": end_time})\n",
    "\n",
    "def reward(_, element: int, reward: float, modality=None):\n",
    "    start_time = time.time()\n",
    "    if modality:\n",
    "        agents[element].process_guiding_reward(reward, modality)\n",
    "    else:\n",
    "        agents[element].process_guiding_reward(reward, None)\n",
    "    end_time = time.time()\n",
    "    timings.append({\"key\": \"guidance\", \"start\": start_time, \"end\": end_time})\n",
    "    # print(f\"Weights updated from {old_weights} to {agent._weights}\"\n",
    "\n",
    "# def zone_reward(_, element: int, reward: float):\n",
    "#     # Calculate length N_STEPS away on each axis, store in agent\n",
    "#     start_time = time.time()\n",
    "#     agents[element].process_zone_reward(reward)\n",
    "#     end_time = time.time()\n",
    "#     timings.append({\"key\": \"zone\", \"start\": start_time, \"end\": end_time})\n",
    "\n",
    "def activate(_, element: int, dimension: int, activation: bool):\n",
    "    print(f\"{element}: Setting dimension {dimension} to {activation}\")\n",
    "    agents[element].update_activation(dimension, activation)\n",
    "    print(f\"{agents[element]._exclude_dims}\")\n",
    "\n",
    "def init(_, element: int, ndims: int, step: float):\n",
    "    if element in agents:\n",
    "        print(f\"Replacing agent {element} with fresh. {ndims} dimensions, initial step {step} (norm)\")\n",
    "    else:\n",
    "        print(f\"New agent {element} with {ndims} dimensions, initial step {step} (norm)\")\n",
    "    #agents[element] = LinearSGDAgent(ndims, step)\n",
    "    if agentType == \"joint\":\n",
    "        agents[element] = NeuralSGDAgent(ndims, step)\n",
    "    elif agentType == \"split\":\n",
    "        agents[element] = SplitNeuralSGDAgent(haptic_dims, ndims - haptic_dims, step)\n",
    "    # elif agentType == \"random\":\n",
    "    #     agents[element] = RandomAgent(ndims, step)\n",
    "\n",
    "def delete(_, element: int):\n",
    "    if element in agents:\n",
    "        print(f\"Deleting agent {element} ({agents[element]._ndims} dimensions)\")\n",
    "        del agents[element]\n",
    "    else:\n",
    "        print(f\"No agent with identifier {element}!\")\n",
    "\n",
    "dispatcher = Dispatcher()\n",
    "dispatcher.set_default_handler(default_handler)\n",
    "dispatcher.map(\"/uistate/setAutonomous\", auto_switch_handler)\n",
    "dispatcher.map(\"/controller/manualSet\", manual_set)\n",
    "dispatcher.map(\"/controller/updateManual\", manual_update)\n",
    "dispatcher.map(\"/controller/jump\", jump_unexplored)\n",
    "dispatcher.map(\"/controller/step\", step)\n",
    "dispatcher.map(\"/controller/reward\", reward)\n",
    "dispatcher.map(\"/controller/activate\", activate)\n",
    "dispatcher.map(\"/controller/init\", init)\n",
    "# dispatcher.map(\"/controller/zone_reward\", zone_reward)\n",
    "\n",
    "ip = \"127.0.0.1\" # localhost\n",
    "port = 8080\n",
    "\n",
    "SERVER_CLOSE = Event()\n",
    "\n",
    "with BlockingOSCUDPServer((ip, port), dispatcher) as server:\n",
    "    def quit_func(address, *args):\n",
    "        print(\"Quit!\")\n",
    "        SERVER_CLOSE.set()\n",
    "    dispatcher.map(\"/quit\", quit_func)\n",
    "    thread = Thread(target=server.serve_forever)\n",
    "    thread.start()\n",
    "    SERVER_CLOSE.wait()\n",
    "    server.shutdown()\n",
    "    thread.join()\n",
    "print(\"And we're out!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}