From: ICLR.cc/2023/Conference/Program_Chairs
title: Paper Decision
decision: Reject
metareview:_summary,_strengths_and_weaknesses: This paper has been evaluated by four reviewers and obtained 2x3 and 2x5 scores. Reviewers had a number of concerns including a vague motivation, issues with the reward module, issues with writing and presentation. The paper requires another round of reviews and cannot be accepted in its present form.
justification_for_why_not_higher_score: Reviewers had a number of concerns including a vague motivation, issues with the reward module, issues with writing and presentation. The paper requires another round of reviews and cannot be accepted in its present form. None of the reviewers was sufficiently satisfied with the rebuttal.
justification_for_why_not_lower_score: N/A

From: ICLR.cc/2023/Conference/Paper3435/Authors
title: Reply to Reviewer BDxC
comment: Thank you for the helpful suggestion and questions. Our reply is as follows:

1. As you suggest, we compare the wall-clock time of the training dynamics of GA2C and AD-GCL. We will present the final time-performance curve in the revision. Here we give the Accuracy results on MUTAG about it:

|Method|	Time=2.8s|	Time=4.2s|	Time=6.7s|	Time=9.7s	|Time=12.9s	|Time=16.0s	|Time=19.1s|
|--|--|--|--|--|--|--|--|
|AD-GCL|	0.8633|	0.8739|	0.8777|	0.7977	|0.8778|	0.8459|	0.8825|
|GA2C|	0.8619	|0.8781|	0.8775|	0.8825	|0.8830	|0.8939|	0.8988|

From the above results, we can find that GA2C performs better than AD-GCL in most cases. Also, the performance of AD-GCL is unstable and it has high variance, while GA2C is more stable than AD-GCL.

2. In Eq. (5), we use TD error to calculate the V-value function, which is not the reward function. As you suggest, we correct Eq. (8), i.e., $V_{i}^{(t)}=\sum_{j=1}^{t}\gamma^{j}D(…)$.

3. As you suggest, we will adjust Lines 12 and 13 in Algorithm 1 into gradient descent format.

4. We feel sorry about making a mistake in Eq. (10). In Eq. (10), Softmax -> Sigmoid.

5. We use ‘standard Actor-Crtic model’ to denote the Actor-Critic model without using advantage, which is different from the advantage Actor-Critic model used in GA2C.

From: ICLR.cc/2023/Conference/Paper3435/Authors
title: Reply to Reviewer bA3w
comment: Thank you for the helpful suggestion and questions. Our reply is as follows:

1. As you suggest, we will improve our paper in the revision, making the introduced idea and proposed method easy to follow.

2. We provided the detailed time complexity analysis in Appendix A. Considering that reviewers are not required to see the Appendix part, we will move the content of the time complexity analysis into the main body of the paper. In this analysis, we consider the overhead of using RL to find the optimal GDA strategy in the current state. Also, we will consider how to design a more efficient RL solution for exploring GDA in future work.

3. $\omega_{i}^{(t)}$ is a GDA parameter vector, representing the probability value of some GDA operation. For example, if we choose GDA as edge removing, for a graph with three nodes (v1, v2, v3), ωi(t) may be [0.1,0.2,0.3;0.4,0.5,0.6;0.7,0.8,0.9]. For the edge from v1 to v2, the probability of removing it is 0.1. Also, we only learn one RL agent (not two RL agents) because using a raw graph as one of two views is a general choice of graph contrastive learning for the graph classification task.

4. In Eq. (3), each element in the Q-function is a $N_{i}\times N_{i}$ vector. We will adjust the format of the Q-function from non-bold to bold, i..e, $Q_{i}^{(t)}-> \mathbf{Q}_{i}^{(t)}$.

5. We use the cumulative difference over T rounds (not the current difference in some round) because the current difference cannot reveal the real requirement for the GDA. As we refer to in the section of Introduction, the GDA is regarded as a Markov decision process, i.e., the current augmented view is dependent on the view of the last time and independent of the view of an earlier time. It has been verified that such an idea is intuitive (Figure 1) and can bring significant benefits in extensive experiments.

6. We will provide a detailed running comparison between GA2C and baselines in the revision. Here we give some examples. When the space complexity of models is the same, the specific running time of GA2C and AD-GCL on the used three datasets is as follows (the epoch number is set as 150):

|Method	|MUTAG|	PROTEINS|	DD|
|--|--|--|--|
|AD-GCL|	87.3 seconds|	419.8 seconds|	601.7 seconds|
|GA2C|	65.3 seconds|	266.2 seconds|	310.6 seconds|

From the above results, we find that GA2C is more efficient than AD-GCL when they have the same space complexity.

7. We use Equations (3) and (5) to learn GDA parameters and Q-value functions, respectively. In the GCL methods with learnable GDA parameters, the GDA parameters can be learned by the MLP, GNN, or their combination. Of course, we can use Equations (3) and (5) to learn node embeddings, if we do so, the whole method will degenerate into a GCL method with frozen GDA parameters.

8. In this paper, we use the GDA operation of edge removing as an instantiation of GA2C because edge removing is a general choice for the graph classification task. Also, GA2C is independent of the choice of GDA operations. Therefore, GA2C allows other GDA operations such as attribute masking, edge perturbation, and even the combination of some GDA operations (e.g., edge removing and attribute masking).

From: ICLR.cc/2023/Conference/Paper3435/Authors
title: Reply to Reviewer mgJu
comment: Thank you for the helpful suggestion and questions. Our reply is as follows:

1. We feel sorry about some inaccurate expressions in the submitted paper, as you mentioned that 'encouraging the two views to be different as far as possible'. The real opinion we want to express is 'encouraging to decrease the redundant information between two views as much as possible'. Also, this opinion has been verified in AD-GCL theoretically.

2. The purpose of the Critic model is to estimate whether or not the current Actor model performs well. In the implementation, the Critic model is designed as three-layer graph neural networks (i.e., Equation (5)).

3. We report the clear numbers as follows:

1) Node classification. 

|Dataset|DGI|MVGRL|GraphCL|	GCA|BGRL|GA2C|
|--|--|--|--|--|--|--|
|Cora	|78.3|	83.1|	72.5|	82.9|	77.9|	83.9|
|CS|	90.0|	-|	-	|91.7|	90.3|	92.1|
|Ogbn-arxiv|	65.9|	-|	63.4|	-|	59.3|	64.4|

2) Link prediction.

|Dataset|DGI|	MVGRL|	CAN|	GMI|	SAIL|	GA2C|
|--|--|--|--|--|--|--|
|Citeseer|	69.0|	94.4|	94.8|	96.0|	98.4|	98.4|
|Computers|	75.1|	74.6|	94.9|	85.5|	94.9|	96.1|
|Photo|	74.2|	73.1|	95.0|	91.9|	94.6|	95.8|

3) Sensitivity analysis. 

|Dataset|	#Layer=1|#Layer=3|#Layer=5|#Layer=7|#Layer=9|
|--|--|--|--|--|--|
|MUTAG|	83.33|	89.39|	88.36|	87.28|	88.36|
|IMDB-B|	47.50|	73.50|	68.40|	70.20|	71.40|
|IMDB-M|	37.87|	48.40|	48.80|	49.90|	47.80|

|Dataset|	lr=1e-1|lr=1e-2|lr=1e-3|lr=1e-4|
|--|--|--|--|--|
|MUTAG|	88.27|	88.36|	87.78|	85.70|
IMDB-B|	71.10|	71.10|	72.50|	70.50|
IMDB-M|	48.00|	49.33|	48.40|	49.87|

|Dataset|	Drop ratio=0 |Drop ratio=0.25 |Drop ratio=0.5 |Drop ratio=0.75 |
|--|--|--|--|--|
|MUTAG|	86.73|	88.86|	86.78|	89.44|
|IMDB-B|	71.30|	72.80|	72.80|	72.50|
|IMDB-M|	47.27|	49.27|	49.00|	49.53|

|Dataset|	$\\lambda=0$ |$\\lambda=1$ |$\\lambda=3$ |$\\lambda=5$ |$\\lambda=7$ |
|--|--|--|--|--|--|
|MUTAG|	87.78|	86.23|	87.75|	88.36|	86.20|
|IMDB-B|	70.90|	71.20|	71.90|	72.80|	72.30|
|IMDB-M|	49.53|	47.53|	48.73|	48.93|	47.60|

4. As you suggest, we will correct all the typo errors in the revision, including your given example ‘bath normalization layer-> batch normalization layer’.

5. As you suggest, we compare RGCL and GA2C as follows:

    a. RGCL uses the GDA operation of node removing, while GA2C uses the GDA operation of edge removing.

    b. The basic idea of RGCL and GA2C is different: RGCL calculates the probability of each node being salient (Equation (8) in [1]) with a GNN-MLP combined encoder and integrates the probability into node embedding (Equation (13) in [1]). However, GA2C calculates the cumulative reward of a group of GDA parameters, which guides the model to learn the most suitable GDA strategy in the current state.

    c. RGCL and GA2C are not contradictory and they have similar principles, i.e., learning GDA parameters by neural networks; they can be combined together because they focus different GDA operations.

[1] Li, Sihang, et al. "Let invariant rationale discovery inspire graph contrastive learning." International Conference on Machine Learning. PMLR, 2022.

From: ICLR.cc/2023/Conference/Paper3435/Authors
title: Reply to Reviewer wbKR
comment: Thank you for the helpful suggestion and questions. Our reply is as follows:

1. We will adjust the word "energize" to "promote" to avoid ambiguity.

2. When GDA evolves progressively, the performance of downstream tasks becomes better. We have illustrated such a phenomenon in Figure 1 in the Introduction. The current GDA can also evolve, but it cannot evolve progressively. As shown in Figure 1(a), the current GDA works at the first 6 epochs and loses its effectiveness after the 6th epoch. To make GDA evolve progressively, we find that the reward-based or RL-based GDA design can do it. 

3. In the current GDA, its update is regarded as an independent process. However, in our method, we see GDA as a Markov decision process, where the augmented view of some time is dependent on the view of the last time and independent of the view of an earlier time.

4. We use the Euclidean distance between the embeddings under two views because the target of GDA is to encourage the two views to be different as far as possible. For the other choices for the reward, we can use negative similarity or other types of distance functions (such as Manhattan Distance and Chebyshev Distance).

5. We report some experimental results in AUC and others in Accuracy since we follow the same metric setting as that of AD-GCL [1].

6. As you suggest, we conduct additional sensitivity experiments covering different values of learning rate and regularization coefficient. The detailed results are as follows:

|Value|Accuracy|
|--|--|
|$\alpha_{E}$=1|0.8722|
|$\alpha_{E}$=5|0.8825|
|$\alpha_{E}$=6|0.8506|
|$\alpha_{E}$=7|NaN|
|$\alpha_{E}$=10|NaN|

We find that when the learning rate is larger than 7, the result becomes NaN.
|Value|Accuracy|
|--|--|
|$\lambda$=-10|NaN|
|$\lambda$=-1|NaN|
|$\lambda$=0|0.8564|
|$\lambda$=10|0.8778|
|$\lambda$=100|0.8833|
|$\lambda$=1000|0.8936|
|$\lambda$=10000|0.8830|

When the regularization coefficient is less than 0, the result becomes NaN. The above experimental results verify that GA2C is robust to learning rate and regularization coefficient.

7. Visualization is commonly used in graph representation analysis [2-5] to estimate the quality of embedding results. In Section 4.6, we use the word ‘cluster’ to denote the 2-dimensional visualization results, not the real cluster or classification. The target of Section 4.6 is to analyze the quality of the embedding results obtained by GA2C qualitatively, so we do not use some metrics such as NMI, ARI, and Accuracy.

[1] Susheel Suresh, Pan Li, Cong Hao, and Jennifer Neville. Adversarial graph augmentation to improve graph contrastive learning. NeurIPS, 2021.

[2] Wang D, Cui P, Zhu W. Structural deep network embedding. KDD, 2016.

[3] Goyal P, Ferrara E. Graph embedding techniques, applications, and performance: A survey. Knowledge-Based Systems, 2018.

[4] S. Lin et al., "Prototypical Graph Contrastive Learning," in IEEE Transactions on Neural Networks and Learning Systems, 2022.

[5] Zhong H, Wu J, Chen C, et al. Graph contrastive clustering. ICCV, 2021.

From: ICLR.cc/2023/Conference/Paper3435/Reviewer_wbKR
confidence: 4: You are confident in your assessment, but not absolutely certain. It is unlikely, but not impossible, that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work.
summary_of_the_paper: This paper mainly focuses on how to improve the current learnable graph data augmentation strategy (GDA). The authors are motivated by the empirical observation that the previous GDA method only works in an early stage of the training process. Therefore, the authors design a new data augmentation strategy using reinforcement learning. To verify the superiority of the proposed method GA2C, the authors show GA2C GA2C outperforms the SOTA GCL models on a series of downstream in 23 datasets.
strength_and_weaknesses: **Strength**
The author introduces reinforcement learning to learn graph augmentation, which is interesting and novel. To verify the effectiveness of the proposed method, the author conducts a comprehensive empirical study.

**Weaknesses**
1. The motivation for introducing reinforcement learning to refine the learnable GDA is vague. although the author presents a section with empirical examples to elaborate on that, the interpretation is less informative. 

- First, the key question that the author raises and hight in the intro. is how a good augmented view evolves to energize graph contrastive learning. using Fig.3 authors conclude this as the evolution of the previous GDA does not being energized in the training. What does the author mean by"energize"? if it refers to the augmentation not being activated during the training. what are the underline problems that lead to this and why non-energized versions are bad for GCL needs to be further verified and explained

- Second, the author also criticizes the current GDA has bottlenecks. But doesn't explain what is the bottleneck.  Why does the author need to make GDA can evolve progressively?  The reviewer believes that current end-to-end learnable GDA can also evolve in training. Thus, what is the difference or significance of the proposed methods?

- More importantly, since the problem of the current GDA is not well explained, the necessity of introducing RL is unclear. What does the RL fix in GDA?

2. Why use the alignment of two augmented views as the reward? It seems unrelated to what the author claim (energize the GDA). The reviewer cannot see any connection and require more explanation on this choice. Is there any other choice for the reward to guide the learnable GDA?

3. Some experiment are reported in AUC and some are reported in Acc. the reviewer think given the prediction and label it is easy to obtain both metrics. 

4. It is kind of weird to see the RL algorithm is robust to learning rate and regularization. Especially, the model is still working when the \lambda is 7 which is an uncommon setting in most machine learning. Can authors give some explanation on why GA2C can achieve this rather than just give the reviewer results?

5. The visualization seems to be unnecessary. It is still hard to say the proposed method is better via Fig.8. If the authors want to show GA2C produces better embedding for clustering. It is better to conduct clustering tasks and there are many metrics (e.g., NMI, ARI, and Acc.) to quantitatively verify the results.
clarity,_quality,_novelty_and_reproducibility: Clarity: Good. It is easy to follow the paper.

Quality: More justification is needed to better show the author's motivation and the necessity of the proposed method.

Novelty: It is novel to introduce RL to GDA

Reproducibility: Not Sure about it.
summary_of_the_review: Overall, it is good try to introduce RL to GCL. However, more justification is needed to better show the author's motivation and the necessity of the proposed method. I would like to increase my evaluation if the author can resolve all of my concerns in the rebuttal.
correctness: 3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.
technical_novelty_and_significance: 2: The contributions are only marginally significant or novel.
empirical_novelty_and_significance: 3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.
flag_for_ethics_review: NO.
recommendation: 3: reject, not good enough

From: ICLR.cc/2023/Conference/Paper3435/Reviewer_mgJu
confidence: 4: You are confident in your assessment, but not absolutely certain. It is unlikely, but not impossible, that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work.
summary_of_the_paper: Traditional graph data augmentation (GDA) strategies regard augmentations as independent processes. This paper considers the GDA as a Markov decision process and develops a reinforced method, named GA2C, to achieve continuous and learnable GDA. Experiments on 17 datasets verify the effectiveness of GA2C.
strength_and_weaknesses: Strength:  
(1)	This paper reformulates the graph data augmentation as a Markov decision process, which can be considered as the fourth type of GDA methods.
(2)	The authors provide a detail design of a reinforced augmentation framework to achieve the Markov-decision-process-based GDA. 
(3)	Experiments for the graph classification task show a huge progress than other baselines on totally 17 datasets. Ablation studies, sensitivity analysis, and visualization prove the sufficiency of detail designs.

Weakness:
(1)	The idea of introducing Reward module for “encouraging the two views to be different as far as possible” may not be solid. If the pair of views is too different, it is impossible to encourage the model to generate similar embeddings for them (Tian, Yonglong, et al. 2020). The authors should guarantee that the two augmented views would not lose the essential topologies.
(2)	The design of Model architecture in Section 3.2 hasn’t been well explained. What is the Critic model, and what is the purpose to introduce this model?
(3)	Experiment results on node classification, link prediction, and sentiment analysis should be reported in tables with clear numbers. 
(4)	Many typo errors appear in the paper. For example, references in the first paragraph of Section 1 miss brackets. “bath normalization layer” in the Section 3.2 should be corrected as “batch normalization layer”. 

Discussion:
(1)	We notice a novel graph data augmentation method, called RGCL, achieve a new SOTA on graph classification tasks. Although this paper is formally published on July 2022, we still expect some discussion on it from this paper. (Li, Sihang, et al. "Let invariant rationale discovery inspire graph contrastive learning." International Conference on Machine Learning. PMLR, 2022.)

clarity,_quality,_novelty_and_reproducibility: Clarity and Quality: This paper is well organized and the writing is OK, but the model architecture should be detailed introduced and there are some minor typo-errors raised. 

Novelty: Considering graph data augmentation as a Markov decision process is novel.

Reproducibility: The author did NOT provide any code about their experiments.

summary_of_the_review: This paper illustrates a novel understanding of graph data augmentation for graph contrastive learning. Although the experiments show considerable progress in classification tasks, the statement that “encouraging the two views to be different as far as possible” may not be solid. Overall, this paper is marginal below the acceptance borderline.
correctness: 3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.
technical_novelty_and_significance: 3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.
empirical_novelty_and_significance: 3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.
flag_for_ethics_review: NO.
recommendation: 5: marginally below the acceptance threshold

From: ICLR.cc/2023/Conference/Paper3435/Reviewer_bA3w
confidence: 3: You are fairly confident in your assessment. It is possible that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work. Math/other details were not carefully checked.
summary_of_the_paper: This paper studies the problem of graph data augmentation for improved effectiveness in graph contrastive learning. The key argument is that all existing graph augmentation methods ignore the connection between consecutively augmented graphs; and the authors proposed to use reinforcement learning to plan the trajectory of augmentations so as to find the most effective ones for contrastive learning. The RL-based optimization of graph augmentation step is embedded into the iterative process of standard graph contrastive learning procedure. Extensive experimentations on a wide collection of graph benchmark datasets were performed to confirm the effectiveness of the proposed solution. 
strength_and_weaknesses: Strength:
+ The idea of using RL to find the most effective graph augmentations sounds reasonable. 
+ The empirical performance on a variety of evaluation datasets supports the effectiveness of the developed solution. 

Weakness:
- The description of the paper is generally very hard to follow, with numerous and complex notations. This unfortunately prevents the review to completely follow the proposed solution.
- There is no hint on the time complexity of this proposed solution. However, training of DeepRL is known to be expensive; and hence, the overhead of using RL to find the most effective graph augmentation should not be neglectable. 
- It is very unclear how the edge removing actions were realized in Eq (3) for the actor. I would assume $\omega_i (t)$ is a $N_i \times N_i$ vector, but how do we obtain its value (presumably binary values) from a batch normalization layer? In addition, as we are supposed to obtain two views at each round of RL, are we learning one RL agent but taking different states (i.e., previous view from the same branch) or two different RL agents? The description in the paper only discusses one branch. 
- Eq (5) almost shared the same structure as in Eq (3), but now it only outputs a scalar for each element in the Q-function. Eq (3) and (5) together really confused me.

Questions:
- There is no explicitly discussion about the key insight in the proposed solution. Based on my understanding, the RL is to find two views that lead to the most different embeddings, which in turn help the graph encoder to better estimate the invariants in the given graph. However, if it is the same, why shall the RL agent care about the cumulative difference over T rounds? What matters should be the final T-th round difference?   
- What’s the running comparison between the proposed solution and baselines? 
- Eq (3) and (5) can be understood as learning node embeddings; why do not we use the learnt graph encoder for this purpose? Or in other words, can the learnt node embeddings from Eq (3) and (5) be useful for downstream tasks?
- As the RL agent keeps removing edges to generate the final augmentation, it will encounter less and less choices in the later steps. Why should we restrict ourselves to edge removing only? Will allowing both edge removal and addition provide more flexibility to the RL-based solution? 

clarity,_quality,_novelty_and_reproducibility: The notations used in the paper are very complex and the description about the algorithm procedures is also hard to follow, which unfortunately caused difficulty in fully understanding the proposed solution. It is preferred if the authors could provide more explanations about the key insight of their solution, e.g., what the RL-based augmentation is looking for and why it is important for graph contrastive learning.   
summary_of_the_review: The lack of clarity, both procedure-wise and purpose-wise, prevents the reviewer to fully appreciate the submission, though the extensive empirical evaluations suggested the effectiveness of the proposed solution. I expect more clarification from the authors during the discussion phase.  
correctness: 3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.
technical_novelty_and_significance: 3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.
empirical_novelty_and_significance: 3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.
flag_for_ethics_review: NO.
recommendation: 5: marginally below the acceptance threshold

From: ICLR.cc/2023/Conference/Paper3435/Reviewer_BDxC
confidence: 4: You are confident in your assessment, but not absolutely certain. It is unlikely, but not impossible, that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work.
summary_of_the_paper: This work proposes to use reinforcement learning to design graph augmentation mechanism used in graph contrastive learning. The benefit of using RL is that the way of graph augmentation can be designed via a markov decision process where a long-term reward and the dependence between different parts of the graph are better captured. The paper adopts an actor-critic model. The actor part is to find the perturbation to enlarge the gap between the representations of different augmentations of the same graph. The critical model is to learn to measure the gap between the representations of different augmentations. Extensive experiments have been adopted to show the benefit. 
strength_and_weaknesses: Strengthes:
1. To my knowledge, it is a new idea to learn to design graph augmentation via reinforcement learning. 

2. Extensive experiments have been done to justify the advantage of the proposed approach. 

3. The motivating example to show the issue of AD-GCL is interesting. 

Weaknesses:
1. The biggest concern about this work is its training complexity. The adversarial training in AD-GCL is already hard. Learning rates should be tuned properly to make AD-GCL converge. If the adversarial part is replaced by reinforcement learning, I can see the pipeline is really hard to tune and the training complexity could be high. I have concern on the practical applicability of this method. I suggest the authors to compare the wall-clock time of the training dynamics of different methods (x-axis: training time, y-axis: validation performance). 

There are quite a few notation issues which make me question the correctness of the algorithm.

2. I do not understand when a critic model is needed. The idea to learn a critic model is because the long-term reward is unknown. However, it seem to me that current formulation has a clear reward defined in (8). Also, why is it needed to be learned? Also, I believe the notation in (8) is wrong: LHS depends on t while RHS sums over t. 

3. Also, in alg 1, the steps 12 and 13 are wrong, where both adopt gradient ascent, which I do not believe is correct. At least, 13 should be gradient descent. 

4. How softmax in (10) is computed? Do you only remove one edge at each step t as the normalization of softmax in (10) is across all edges? If so, when action space in (A) is not one hot encoding but denotes the set of edges. 

5. In 4.3, what is standard actor-critic model? It is a common sense to build an AC model for graph contrastive learning. Please clarify the standard AC model and explain your difference. 


clarity,_quality,_novelty_and_reproducibility: Clarity: The language description is okay. However, the notations cause a lot of confusion as said above. 

Quality: There are a few technical issues as introduced above. Also, I have concern on the training complexity and the applicability of the proposed approach. 

Novelty: I think it is new to consider RL used in graph contrastive learning. 

Reproducibility: I also have a few concerns on this aspect. As the proposed method is based on RL and many details behind the algorithm are not well explained. 

summary_of_the_review: The work studies a new angle to learn graph augmentation for graph contrastive learning. However, due to many notation issues, incorrect technical descriptions, and my concerns on RL training, I cannot give a recommendation on this work. 
correctness: 2: Several of the paper’s claims are incorrect or not well-supported.
technical_novelty_and_significance: 3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.
empirical_novelty_and_significance: 2: The contributions are only marginally significant or novel.
flag_for_ethics_review: NO.
recommendation: 3: reject, not good enough