elumixor

//
// Created by Vladyslav Yazykov on 28/12/2018.
//

#ifndef BEZIER_POLYNOMIAL_H
#define BEZIER_POLYNOMIAL_H

#include <cstdlib>
#include <initializer_list>

elumixor

//
// Created by Vladyslav Yazykov on 17/12/2018.
//

#include <random>
#include "float.h"

namespace math {
    template<int power>
    struct TSign {

elumixor

using UnityEditor;
using UnityEngine;

namespace Shared.SingletonBehaviour {
    /// <summary>
    /// Singleton is not guaranteed to be initialized at OnValidate and Awake
    /// </summary>
    /// <typeparam name="T"></typeparam>
    [ExecuteInEditMode]
    public class SingletonBehaviour<T> : MonoBehaviour where T : SingletonBehaviour<T> {

elumixor

from visualizer import visualize
from YOUR_CLASSIFIER import YourClassifier

if __name__ == '__main__':
    # Load data
    model = G2Model(**data)

    sample_size = int(2e4)
    training_set = model.generate_sample(sample_size)
    

elumixor

import numpy as np
import torch
from torch.utils.data import SubsetRandomSampler, DataLoader
from time import sleep
from IPython.display import clear_output, display

import os


class Trainer:

elumixor

from collections import namedtuple

import gym
import torch

env = gym.make('CartPole-v0')

obs_size = env.observation_space.shape[0]
num_actions = env.action_space.n

elumixor

import torch.nn as nn

actor_hidden = 32
actor = nn.Sequential(nn.Linear(state_size, actor_hidden),
                      nn.ReLU(),
                      nn.Linear(actor_hidden, num_actions),
                      nn.Softmax(dim=1))

elumixor

from torch.distributions import Categorical


def get_action(state):
    state = torch.tensor(state).float().unsqueeze(0)  # Turn state into a batch with a single element
    dist = Categorical(actor(state))  # Create a distribution from probabilities for actions
    return dist.sample().item()

elumixor

# Critic takes a state and returns its values
critic_hidden = 32
critic = nn.Sequential(nn.Linear(obs_shape[0], critic_hidden),
                       nn.ReLU(),
                       nn.Linear(critic_hidden, 1))

elumixor

from torch.optim import Adam


critic_optimizer = Adam(critic.parameters(), lr=0.005)


def update_critic(advantages):
    loss = .5 * (advantages ** 2).mean()
    critic_optimizer.zero_grad()
    loss.backward()