Update app.py

app.py

@@ -10,13 +10,18 @@ pragformer_reduction = transformers.AutoModel.from_pretrained("Pragformer/PragFo
 
 
 #Event Listeners
+with_omp_str = 'Should contain a parallel work-sharing loop construct'
+without_omp_str = 'Should not contain a parallel work-sharing loop construct'
+
 tokenizer = transformers.AutoTokenizer.from_pretrained('NTUYG/DeepSCC-RoBERTa')
 
 with open('c_data.json', 'r') as f:
     data = json.load(f)
 
 def fill_code(code_pth):
-    return data[code_pth]['pragma'], data[code_pth]['code']
+    pragma = data[code_pth]['pragma']
+    code = data[code_pth]['code']
+    return 'None' if len(pragma)==0 else pragma, code
   
 
 def predict(code_txt):
@@ -30,47 +35,47 @@ def predict(code_txt):
     pred = pragformer(torch.tensor(tokenized['input_ids']), torch.tensor(tokenized['attention_mask']))
 
     y_hat = torch.argmax(pred).item()
-    return 'With OpenMP' if y_hat==1 else 'Without OpenMP', torch.nn.Softmax(dim=1)(pred).squeeze()[y_hat].item()
+    return with_omp_str if y_hat==1 else without_omp_str, torch.nn.Softmax(dim=1)(pred).squeeze()[y_hat].item()
 
 
 def is_private(code_txt):
-  if predict(code_txt)[0] == 'Without OpenMP':
-      return gr.update(visible=False)
+    if predict(code_txt)[0] == without_omp_str:
+        return gr.update(visible=False)
 
-  code = code_txt.lstrip().rstrip()
-  tokenized = tokenizer.batch_encode_plus(
-            [code],
-            max_length = 150,
-            pad_to_max_length = True,
-            truncation = True
-        )
-  pred = pragformer_private(torch.tensor(tokenized['input_ids']), torch.tensor(tokenized['attention_mask']))
+    code = code_txt.lstrip().rstrip()
+    tokenized = tokenizer.batch_encode_plus(
+                [code],
+                max_length = 150,
+                pad_to_max_length = True,
+                truncation = True
+            )
+    pred = pragformer_private(torch.tensor(tokenized['input_ids']), torch.tensor(tokenized['attention_mask']))
 
-  y_hat = torch.argmax(pred).item()
-  if y_hat == 0:
-      return gr.update(visible=False)
-  else:
-      return gr.update(value=f"Confidence: {torch.nn.Softmax(dim=1)(pred).squeeze()[y_hat].item()}", visible=True)
+    y_hat = torch.argmax(pred).item()
+    # if y_hat == 0:
+    #     return gr.update(visible=False)
+    # else:
+    return gr.update(value=f"{'should not contain private' if y_hat==0 else 'should contain private'} with confidence: {torch.nn.Softmax(dim=1)(pred).squeeze()[y_hat].item()}", visible=True)
 
 
 def is_reduction(code_txt, label):
-  if predict(code_txt)[0] == 'Without OpenMP':
-      return gr.update(visible=False)
-      
-  code = code_txt.lstrip().rstrip()
-  tokenized = tokenizer.batch_encode_plus(
-            [code],
-            max_length = 150,
-            pad_to_max_length = True,
-            truncation = True
-        )
-  pred = pragformer_reduction(torch.tensor(tokenized['input_ids']), torch.tensor(tokenized['attention_mask']))
-
-  y_hat = torch.argmax(pred).item()
-  if y_hat == 0:
-      return gr.update(visible=False)
-  else:
-      return gr.update(value=f"Confidence: {torch.nn.Softmax(dim=1)(pred).squeeze()[y_hat].item()}", visible=True)
+    if predict(code_txt)[0] == without_omp_str:
+        return gr.update(visible=False)
+
+    code = code_txt.lstrip().rstrip()
+    tokenized = tokenizer.batch_encode_plus(
+                [code],
+                max_length = 150,
+                pad_to_max_length = True,
+                truncation = True
+            )
+    pred = pragformer_reduction(torch.tensor(tokenized['input_ids']), torch.tensor(tokenized['attention_mask']))
+
+    y_hat = torch.argmax(pred).item()
+    # if y_hat == 0:
+    #     return gr.update(visible=False)
+    # else:
+    return gr.update(value=f"{'should not contain reduction' if y_hat==0 else 'should contain reduction'} with confidence: {torch.nn.Softmax(dim=1)(pred).squeeze()[y_hat].item()}", visible=True)
 
 
 # Define GUI
@@ -88,12 +93,12 @@ with gr.Blocks() as pragformer_gui:
         gr.Markdown("## Input")
         with gr.Row():
             with gr.Column():
-                drop = gr.Dropdown(list(data.keys()), label="Random Code Snippet", value="Adahn/Project_Parallelism/version2/MPI/main/2")
+                drop = gr.Dropdown(list(data.keys()), label="Mix of parallel and not-parallel code snippets", value="Minyoung-Kim1110/OpenMP/Excercise/atomic/0")
                 sample_btn = gr.Button("Sample")
             
-            pragma =  gr.Textbox(label="Pragma")
+            pragma =  gr.Textbox(label="Original Parallelization Classification (if any)")
 
-        code_in = gr.Textbox(lines=5, label="Write some code and see if it should be parallelized with OpenMP")
+        code_in = gr.Textbox(lines=5, label="Write some code and see if it should contain a parallel work-sharing loop construct")
         submit_btn = gr.Button("Submit")
     with gr.Column():
         gr.Markdown("## Results")
@@ -113,6 +118,20 @@ with gr.Blocks() as pragformer_gui:
 
     gr.Markdown(
     """
+
+    ## How it Works?
+
+    To use the PragFormer tool, you will need to input a C language for-loop. You can either write your own code or use the samples
+    provided in the dropdown menu, which have been gathered from GitHub. Once you submit the code, the PragFormer model will analyze
+    it and predict whether the for-loop should be parallelized using OpenMP. If the PragFormer model determines that parallelization
+    is necessary, two additional models will be used to determine if adding specific data-sharing attributes, such as ***private*** or ***reduction*** clauses, is needed.
+
+    ***private***- Specifies that each thread should have its own instance of a variable. 
+
+    ***reduction***- Specifies that one or more variables that are private to each thread are the subject of a reduction operation at 
+    the end of the parallel region.
+
+
     ## Description
     
     In past years, the world has switched to many-core and multi-core shared memory architectures.
@@ -132,16 +151,12 @@ with gr.Blocks() as pragformer_gui:
 
     ![](https://user-images.githubusercontent.com/104314626/165228036-d7fadd8d-768a-4e94-bd57-0a77e1330082.png)
 
+    Link to [PragFormer](https://arxiv.org/abs/2204.12835) Paper
 
-    ## How it Works?
-
-    To use the PragFormer tool, you will need to input a C language for-loop. You can either write your own code or use the samples
-    provided in the dropdown menu, which have been gathered from GitHub. Once you submit the code, the PragFormer model will analyze
-    it and predict whether the for-loop should be parallelized using OpenMP. If the PragFormer model determines that parallelization
-    is necessary, two additional models will be used to determine if ***private*** or ***reduction*** clauses are needed.
     """)
 
 
+pragformer_gui.launch()
 
 pragformer_gui.launch()