diff --git a/agent/DDPG_agent.py b/agent/DDPG_agent.py
index 19f26d0..a21229b 100644
--- a/agent/DDPG_agent.py
+++ b/agent/DDPG_agent.py
@@ -97,7 +97,7 @@ class DDPGAgent:
                 actions = actor.predict(states, False)
                 var_actions = Variable(actions.data, requires_grad=True)
                 q = critic.predict(states, var_actions)
-                q.backward(torch.ones(q.size()))
+                q.backward(critic.FloatTensor(np.ones(q.size())))
 
                 actor.zero_grad()
                 self.actor_opt.zero_grad()
diff --git a/main.py b/main.py
index 683f407..2fde040 100644
--- a/main.py
+++ b/main.py
@@ -286,15 +286,14 @@ def ddpg_continuous():
     # config.task_fn = lambda: BipedalWalker()
     task = config.task_fn()
     config.actor_network_fn = lambda: DeterministicActorNet(
-        task.state_dim, task.action_dim, F.tanh, 1, non_linear=F.relu, batch_norm=False)
+        task.state_dim, task.action_dim, F.tanh, 1, non_linear=F.relu, batch_norm=False, gpu=False)
     config.critic_network_fn = lambda: DeterministicCriticNet(
-        task.state_dim, task.action_dim, non_linear=F.relu, batch_norm=False)
+        task.state_dim, task.action_dim, non_linear=F.relu, batch_norm=False, gpu=False)
     config.network_fn = lambda: DisjointActorCriticNet(config.actor_network_fn, config.critic_network_fn)
     config.actor_optimizer_fn = lambda params: torch.optim.Adam(params, lr=1e-4)
     config.critic_optimizer_fn =\
         lambda params: torch.optim.Adam(params, lr=1e-3, weight_decay=0.01)
-    config.replay_fn = lambda: SharedReplay(memory_size=1000000, batch_size=64,
-                                            state_shape=(task.state_dim, ), action_shape=(task.action_dim, ))
+    config.replay_fn = lambda: HighDimActionReplay(memory_size=1000000, batch_size=64)
     config.discount = 0.99
     config.max_episode_length = task.max_episode_steps
     config.random_process_fn = \
@@ -320,11 +319,11 @@ if __name__ == '__main__':
 
     # dqn_cart_pole()
     # async_cart_pole()
-    a3c_cart_pole()
+    # a3c_cart_pole()
     # a3c_continuous()
     # p3o_continuous()
     # d3pg_continuous()
-    # ddpg_continuous()
+    ddpg_continuous()
 
     # dqn_fruit()
     # hrdqn_fruit()
diff --git a/network/continuous_action_network.py b/network/continuous_action_network.py
index 1ad91ff..77f59b6 100644
--- a/network/continuous_action_network.py
+++ b/network/continuous_action_network.py
@@ -29,22 +29,18 @@ class DeterministicActorNet(nn.Module, BasicNet):
         self.layer2 = nn.Linear(hidden_size, hidden_size)
 
         self.batch_norm = batch_norm
-        BasicNet.__init__(self, None, gpu, False)
         self.init_weights()
+        BasicNet.__init__(self, None, gpu, False)
 
     def init_weights(self):
         bound = 3e-3
-        self.layer3.weight.data.uniform_(-bound, bound)
-        self.layer3.bias.data.fill_(0)
+        nn.init.uniform(self.layer3.weight.data, -bound, bound)
+        nn.init.constant(self.layer3.bias.data, 0)
 
-        def fanin(size):
-            v = 1.0 / np.sqrt(size[1])
-            return torch.FloatTensor(size).uniform_(-v, v)
-
-        self.layer1.weight.data = fanin(self.layer1.weight.data.size())
-        self.layer1.bias.data.fill_(0)
-        self.layer2.weight.data = fanin(self.layer2.weight.data.size())
-        self.layer2.bias.data.fill_(0)
+        nn.init.xavier_uniform(self.layer1.weight.data)
+        nn.init.constant(self.layer1.bias.data, 0)
+        nn.init.xavier_uniform(self.layer2.weight.data)
+        nn.init.constant(self.layer2.bias.data, 0)
 
     def forward(self, x):
         x = self.to_torch_variable(x)
@@ -83,22 +79,18 @@ class DeterministicCriticNet(nn.Module, BasicNet):
             self.bn2 = nn.BatchNorm1d(hidden_size)
         self.batch_norm = batch_norm
 
-        BasicNet.__init__(self, None, gpu, False)
         self.init_weights()
+        BasicNet.__init__(self, None, gpu, False)
 
     def init_weights(self):
         bound = 3e-3
-        self.layer3.weight.data.uniform_(-bound, bound)
-        self.layer3.bias.data.fill_(0)
+        nn.init.uniform(self.layer3.weight.data, -bound, bound)
+        nn.init.constant(self.layer3.bias.data, 0)
 
-        def fanin(size):
-            v = 1.0 / np.sqrt(size[1])
-            return torch.FloatTensor(size).uniform_(-v, v)
-
-        self.layer1.weight.data = fanin(self.layer1.weight.data.size())
-        self.layer1.bias.data.fill_(0)
-        self.layer2.weight.data = fanin(self.layer2.weight.data.size())
-        self.layer2.bias.data.fill_(0)
+        nn.init.xavier_uniform(self.layer1.weight.data)
+        nn.init.constant(self.layer1.bias.data, 0)
+        nn.init.xavier_uniform(self.layer2.weight.data)
+        nn.init.constant(self.layer2.bias.data, 0)
 
     def forward(self, x, action):
         x = self.to_torch_variable(x)