load data but find AttrView error

[AmgadAbdallah]

Hello,
I'm trying to create a reply buffer for my deep reinforcement learning agent... I need to append Data objects in lists an then use a sample from this list to be a batch for GNN... Nevertheless, I face the following error...any help?

raise AttributeError(f"Cannot access attribute '{key}' on view "
AttributeError: Cannot access attribute 'x' on view 'AttrView(store=Data(x=[20, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None))' as all attributes have already been set in this view

[rusty1s]

Do you have a reproducible example? Not totally sure why your data objects are of type AttrView.

[AmgadAbdallah]

Hey... sure,

here is the reply buffer:

import random
from collections import deque
import torch

class ReplayBuffer:
    def __init__(self, batch_size):
        self.replay_buffer = deque(maxlen=500)
        self.batch_size = batch_size
        self.device = torch.device("cpu")

    def sample(self):
        samples = random.sample(self.replay_buffer, k=self.batch_size)

        # states = torch.stack([s[0] for s in samples])
        # states_list = [s[0] for s in samples]
        states = [s[0] for s in samples]
        actions = torch.stack([s[1] for s in samples]).float().to(self.device)
        rewards = (
            torch.tensor([s[2] for s in samples]).float().unsqueeze(1).to(self.device)
        )
        # next_states = torch.stack([s[3] for s in samples])
        next_states = [s[3] for s in samples]
        # next_states = DataLoader(states_list_, batch_size=self.batch_size)

        dones = (
            torch.tensor([s[4] for s in samples]).float().unsqueeze(1).to(self.device)
        )
        return states, actions, rewards, next_states, dones

    def add(self, sars):
        self.replay_buffer.append(sars)

this is a part from the agent class that does sampling:

 def select_actions(self, state):
        self.actor.train()
        with torch.no_grad():
            probabilities, actions, log_p = self.actor.sample(state, self.action_space)
        return probabilities, actions, log_p

    def train(self):
        if len(self.replay_buffer.replay_buffer) < self.batch_size:
            return

        samples = self.replay_buffer.sample()
        states = samples[0]
        probabilities = samples[1]
        rewards = samples[2]
        next_states = samples[3]
        dones = samples[4]

        current_q_1 = self.critic_q_1(states, probabilities)
        current_q_2 = self.critic_q_2(states, probabilities)
        current_critic_v = self.critic_v(states)

        _, _, log_p = self.actor.sample(states, self.env.action_space.nvec.tolist())

my graph encoder:

class GraphEncoder(nn.Module):
    def __init__(self, state, n_layers=1, dim_h=128, heads=4):
        super().__init__()
        num_node_features = state.num_node_features
        self.conv1 = GAT(num_node_features, dim_h, n_layers, v2=True, heads=heads)
        self.conv2 = GIN(dim_h, dim_h, n_layers)

        self.fc1 = nn.Linear(dim_h, dim_h)
        self.fc2 = nn.Linear(dim_h, dim_h)

    def forward(self, state, batch=None):
        x, edge_index = state.x, state.edge_index
        h1 = self.conv1(x, edge_index)
        h2 = self.conv2(h1, edge_index)

        h = global_add_pool(h2, batch)

        x = self.fc1(h)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        return x

This is code for state value function... I know the try and except here looks stupid but it's for testing only and will be removed so please don't judge me based on that :)

class StateValueNetwork(nn.Module):
    def __init__(self, states, dim_h=128, chkpt_dir='tmp/GeomSac'):
        super().__init__()
        self.mol_encoder = GraphEncoder(states)
        self.fc1 = nn.Linear(dim_h, dim_h)
        self.fc2 = nn.Linear(dim_h, 64)
        self.fc3 = nn.Linear(64, 1)
        self.chkpt_dir = chkpt_dir
        self.chkpt_file = os.path.join(self.chkpt_dir, 'value_geom_sac')

    def forward(self, state):
        try:
            state_ = self.mol_encoder(state)
            x = self.fc1(state_)
            x = F.relu(x)
            x = self.fc2(x)
            x = F.relu(x)
            x = self.fc3(x)
            return x
        except:
            samples = []
            # sample_loader = DataLoader(state, batch_size=2)
            for i in state:
                samples.append(self.mol_encoder(i))
            state_ = torch.stack(samples)
            x = self.fc1(state_)
            x = F.relu(x)
            x = self.fc2(x)
            x = F.relu(x)
            x = self.fc3(x)
            return x

the main function loop:

for episode in range(n_episodes):
    state = env.reset(frame_work='pyg')
    agent = SoftActorCriticAgent(env, state)
    rewards = 0
    done = False
    steps = 0
    while not done:
        steps += 1
        probabilities, actions, log_p = agent.select_actions(state)
        next_state, reward, done, info = env.step(actions[0].detach().cpu().numpy())
        agent.replay_buffer.add(
            (
                state.detach().view(-1),
                probabilities.view(-1),
                reward,
                next_state.detach().view(-1),
                done,
            )
        )
        agent.train()
        state = next_state
        rewards += reward
    actor_loss.append([x.item() for x in agent.ac_loss])

[rusty1s]

So I guess the error happens in

def forward(self, state, batch=None):
        x, edge_index = state.x, state.edge_index

which gets called in

state_ = self.mol_encoder(state)

Where does state come from in StateValueNetwork, and what is state here? What does print(state) return?

[AmgadAbdallah]

The state that goes into StateValueNetwork comes from a sample from the reply buffer.
The state is suppose to be Data object after converting molecular graph to be digested by PYG.

here is the printed state that goes into def forward(self, state, batch=None): x, edge_index = state.x, state.edge_index````: Data(x=[21, 17], edge_index=[2, 44], edge_attr=[44, 4]) ```

and here is the state when it comes into the state value function:

1 [AttrView(store=Data(x=[21, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None)), AttrView(store=Data(x=[20, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None))]
state_encoer [AttrView(store=Data(x=[21, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None)), AttrView(store=Data(x=[20, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None))]
2 [AttrView(store=Data(x=[21, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None)), AttrView(store=Data(x=[20, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None))]
AttrView(store=Data(x=[21, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None))
state_encoer AttrView(store=Data(x=[21, 17], edge_index=[2, 44], edge_attr=[44, 4]), attr=DataTensorAttr(group_name=None, attr_name=-1, index=None))```