Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+assets/Project_CodeNet_statistics.xlsx filter=lfs diff=lfs merge=lfs -text
+model-experiments/token-based-similarity-classification/CodeMLtranslationDataset.pdf filter=lfs diff=lfs merge=lfs -text
+model-experiments/token-based-similarity-classification/LargeDataCodeClassifier.pdf filter=lfs diff=lfs merge=lfs -text
+model-experiments/token-based-similarity-classification/LargeDataCodeSimilarity.pdf filter=lfs diff=lfs merge=lfs -text
+tools/json-graph/graph-json.pdf filter=lfs diff=lfs merge=lfs -text

Container/Dockerfile

@@ -0,0 +1,21 @@
+FROM centos:centos8
+ 
+RUN yum -y update; yum clean all
+RUN yum -y install net-tools iproute unzip git
+RUN yum -y install openssh-server openssh-clients
+
+RUN ssh-keygen -f /etc/ssh/ssh_host_rsa_key -N '' -t rsa
+RUN ssh-keygen -f /etc/ssh/ssh_host_ed25519_key -N '' -t ed25519
+RUN ssh-keygen -f /etc/ssh/ssh_host_ecdsa_key -N '' -t ecdsa
+
+RUN yum -y install wget tar maven gcc-c++
+RUN yum -y install java-1.8.0-openjdk
+
+
+RUN mkdir -p /root/.ssh
+COPY ./authorized_keys /root/.ssh/
+
+COPY ./start_container.sh /root/
+
+EXPOSE 22
+ENTRYPOINT ["/root/start_container.sh"]

Container/README.md

@@ -0,0 +1,26 @@
+Creating container that provides a 'VM' in which to experiment with the tools.
+
+1. Place a public keys for ssh into file 'authorized_keys' in the 'Container' directory
+
+2. docker build -t centos8_plain:v1 .
+
+3. docker run --init -d centos8_plain:v1 .
+
+4. docker ps -a
+   docker logs <containerid>
+
+   The log contains the network config of the container,
+   from which the ip address can be extracted.
+
+   An alternative is to 'inspect' the container.
+
+5. ssh root@<container-ip-address>
+
+   If the host from which the ssh is initiated has proper access to
+   the docker network and the private key matching one of the
+   public keys deposited into the container, this allows
+   access similar to a real system/VM.
+   If the container has internet access, 'yum install ...' and
+   'git clone ...' inside the container work as well to
+   expand functionality.
+   

Container/start_container.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+echo "Starting container"
+
+ifconfig
+
+/usr/sbin/sshd -D
+

Contest/ExampleSimAnalysis/README.md

@@ -0,0 +1,89 @@
+# Example of contest test set evaluation
+
+Author: [Vladimir Zolotov](mailto:zolotov@us.ibm.com)
+
+
+This directory holds an example of program `TestSetEval.py` and `scrip test_eval.sh` for evaluating a contest test set on source code similarity.
+
+The program is given only as an example. It is expected that the contestants write their own test set evaluation program better suitable for their operational environment, file formats and ML framework.
+
+The program `TestSetEval.py`  accepts a test set consisting of two components:
+
+1. Directory with source code files of C++ programs to detect similarity or dissimilarity with each other.
+2. csv file of a test set in the following format:
+
+`<sample number>,<path to 1-st file>,<path to 2-nd file>`
+
+where `path to 1-st file` and `path to 2-nd file` specify paths to the pair of files to detect similarity or dissimilarity. The paths are specified relative to the directory with source code files. Here is an example of the csv file of the test set:
+
+```
+pair-id,file1,file2
+1,p02761/s682789980.cpp,p02761/s060579067.cpp
+2,p02817/s224840938.cpp,p03360/s804824036.cpp
+3,p01085/s591760635.cpp,p01085/s734466918.cpp
+```
+
+The program `TestSetEval.py` can also accept a csv file of ground truth labels in the following format:
+`<sample number>,<label>`. Here is an example of the file with ground truth labels:
+
+```
+pair-id,similar
+1,1
+2,0
+3,1
+```
+
+The program `TestSetEval.py`  write down the computed similarity predictions as a csv file in the following format:
+
+`<sample number>,<path to 1-st file>,<path to 2-nd file>,<similarity score><prediction>`
+
+where `similarity score` is the computed probability that the pair of files are similar and, `prediction` is the computed prediction of the similarity. Here is an example of this file:
+
+```
+pair-id,file1,file2,confidence,prediction
+1,f8610.cpp,f8588.cpp,0.06234602,Dissimilar
+2,f1089.cpp,f9389.cpp,0.15431221,Dissimilar
+3,f9570.cpp,f9593.cpp,0.89995503,Similar
+```
+
+If the file with ground truth labels is given the program also computes the accuracy of the test set evaluation and prints it to the console report.
+
+The program uses the Codenet tokenizer from https://github.com/IBM/Project_CodeNet/tree/main/tools/tokenizer and 
+Keras API of TensorFlow ML framework.  However, it can be easily modified to  for a different ML framework.
+
+Program has the following arguments:
+*  The directory with source code files to analyze similarity.
+*  The csv file with sample pairs to analyze similarity
+*  The path to tokenizer of source code files. This should be the Codenet tokenizer from https://github.com/IBM/Project_CodeNet/tree/main/tools/tokenizer. Its default value is `tokenize`.
+*  The TensorFlow checkpoint file with the trained DNN. Its default value is `./dnn_ckpt`.
+*  The csv file with ground truth labels. If it is omitted the program does not compute the accuracy of testset evaluation.
+*  The file to write down the computed similarity predictions.
+*  The batch size.  Its default value is 400.
+*  The mode of Keras training progress bar. By default the program depicts the progress bar on the console.
+
+The program usage can be obtained with the command: `python TestSetEval.py -h`, which gives the following output:
+
+```
+usage: TestSetEval [-h] [--labels LABELS] [--dnn DNN] [--tokenizer TOKENIZER]
+                   [--predictions PREDICTIONS] [--batch BATCH]
+                   [--progress {0,1,2}]
+                   source_code test
+
+positional arguments:
+  source_code           directory with source code files to analyze similarity
+  test                  file with sample pairs to analyze similarity
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --labels LABELS       file with similarity labels of test samples
+  --dnn DNN             checkpoint file with trained dnn
+  --tokenizer TOKENIZER
+                        path to tokenizer of source code files
+  --predictions PREDICTIONS
+                        file to write similarity predictions
+  --batch BATCH         batch size
+  --progress {0,1,2}    mode of Keras training progress bar
+```
+
+The directory has also a script  calling the program with and without ground truth labels.
+

Contest/ExampleSimAnalysis/TestSetEval.py

@@ -0,0 +1,259 @@
+"""
+Program for predicting similarity of testset samples.
+- The DNN is loaded from a given TensorFlow check point.
+- The testset is a csv file with the following format:
+  <sample number>,<relative path to 1-st file>,<relative path to 2-nd file>
+- The program converts source code into token sequences
+  using the tokenizer from Project_CodeNet
+- Tokens coding is defined with dictionary of tokens hard coded in the program.
+- It is required that tokens coding is the same as the one used for DNN training.
+- More examples of token dictionaries can be found in  Project_CodeNet Github
+- Additionally to the testset the program can read a csv file with ground truth labels of the test set sample if it is given
+- The file with labels has the following format:
+  <sample number>,<label>
+    * The label = 1 for similar source code files, otherwise label = 0
+- The program computes the average accuracy of detecting similarity and dissimilarity of test set samples, if labels are defined
+- The program also writes down file csv file with predicted probabilities that samples represent similar source code files
+
+The program uses the following components:
+- The tokenizer from Project_CodeNet 
+- Keras API of TensorFlow ML framework
+
+Program arguments are described at the end of the file
+"""
+import sys
+import os
+import argparse
+import csv
+import numpy as np
+import tensorflow as tf
+
+def makeTokenSet():
+    """
+    Make a token set 
+    The set of tokens must be the same as it used for trainning the DNN
+    Here we make a CPP56X token set of C++ tokens
+    Returns a dictionary of tokens:
+    - Key is a string representing the token
+    - Value is integer value of token
+    """
+    #CPP56 OPERATORS
+    operators = [
+        "=", "+", "-", "*", "/",                  #Assignment and arithmetic operators
+        "%", "&", "|", "^", "~", "<<", ">>",      #Bitwise Operators
+        "+=", "-=", "*=", "/=", "%=", "++", "--", #Compound arithmetic assignment operators
+        "&=", "|=", "^=", "<<=", ">>=",           #Compound bitwise assignment operators
+        "==", "!=", "<", "<=", ">", ">=",         #Comparison operators
+        "?", "&&", "||", "!",                     #Logical operators
+        "(", ")", "{", "}", "[", "]", "->",
+        ";", ","]                                 #Others    
+    #CPP56 KEYWORDS
+    keywords= ["if", "else", "for", "while",
+               "switch", 
+               "enum", "int", "char", "short", "long",
+               "float", "double", "bool"]
+    #CPP SYNONYMS
+    synonyms = {"and": "&&", "or": "||", "not": "!"}
+
+    token_dict = {}
+    for _i, _op in enumerate(operators + keywords):
+        token_dict[_op] = _i
+    print(f"Token set of {len(token_dict)} tokens is constructed")    
+    for _syn, _orig in synonyms.items():
+        token_dict[_syn] = token_dict[_orig]
+    print(f"Additionally it has {len(synonyms)} synonym tokens")    
+    return token_dict
+
+#Dictionary of tokens and their indicies
+token_set = makeTokenSet()
+
+def tokenizeFile(filename, tokenizer):
+    """
+    Tokenize a given file
+    Parameters:
+    - filename     -- name of source code file to tokenize
+    - tokenizer -- path to tokenizer executable
+    Returns:
+    - a list of integer token values representing the source code file
+    """
+    #Name of temporary file for tokenized source code
+    TMP_TOKENIZATION = "./t_o_k_e_n_s.o_u_t"
+    #Tokenization command ignoring macros
+    #tokenize_cmd = tokenizer + " -wcmcsv"
+    #Tokenization command tokenising macros
+    tokenize_cmd = tokenizer + " -wmcsv"
+    if os.system(f"{tokenize_cmd}  -o {TMP_TOKENIZATION} {filename}"):
+        sys.exit(f"Tokenization error in file {filename}")
+    tokens = []
+    with open(TMP_TOKENIZATION, newline='',
+              encoding="ISO-8859-1") as csvfile:
+        token_reader = csv.reader(csvfile)
+        token_reader.__next__() #Skip csv header
+        for _, _, _tok_class, _tok_value in token_reader:
+            if _tok_class == "operator" or _tok_class == "keyword":
+                try:
+                    tokens.append(token_set[_tok_value] + 1)
+                except KeyError:
+                    #ignore tokens that are not in the tokens set
+                    pass
+    return tokens
+
+def makeDataset(source, test, tokenizer):
+    """
+    Make tensorflow dataset 
+    for predicting similarity of testset samples with Simaese DNN
+    Parameters:
+    - source    -- path to directory with source code files 
+                   to analyze similarity
+    - test      -- path to the testsetrfile specifying pairs 
+                   of source code file to analyze similarity
+    - tokenizer -- path to tokenizer executable
+    Returns:
+    - dataset as list of two numpy arrays.
+      Each numpy array represets set of token sequences for one input of DNN
+    """   
+    tokenizations = {}
+    samples = []
+    max_code_len = 0
+    with open(test, newline='') as csvfile:
+        test_reader = csv.reader(csvfile)
+        test_reader.__next__() #Skip csv header
+        for _num, fn1, fn2 in test_reader:
+            try:
+                tok_seq1 = tokenizations[fn1]
+            except KeyError:
+                tok_seq1 = tokenizeFile(source + '/' + fn1, tokenizer)
+                tokenizations[fn1] = tok_seq1
+                max_code_len = max(max_code_len, len(tok_seq1))
+            try:
+                tok_seq2 = tokenizations[fn2]
+            except KeyError:
+                tok_seq2 = tokenizeFile(source + '/' + fn2, tokenizer)
+                tokenizations[fn2] = tok_seq2                
+                max_code_len = max(max_code_len, len(tok_seq2))
+            samples.append((tok_seq1, tok_seq2))
+    np_ds1 = np.zeros(shape=(len(samples), max_code_len), 
+                      dtype=np.int32)
+    np_ds2 = np.zeros(shape=(len(samples), max_code_len), 
+                      dtype=np.int32)
+    for _i, _s in enumerate(samples):
+        tok_seq1, tok_seq2 = _s
+        np_ds1[_i][0:len(tok_seq1)] = np.asarray(tok_seq1, dtype=np.int32)
+        np_ds2[_i][0:len(tok_seq2)] = np.asarray(tok_seq2, dtype=np.int32)
+    print(f"Dataset of {len(samples)} samples is constructed")
+    return [np_ds1, np_ds2]
+
+def loadLabels(filename):
+    """
+    Load ground truth lables if they exist
+    Parameters:
+    - filename  -- Path to labels file
+    Returns:
+    - numpy array with labels to compare with the predicted similarity
+      or None if no ground truth lables are provided
+    """
+    if filename is None:
+        print("Labels of test samples are not specified")
+        print("Accuracy of DNN on this test cannot be evaluated")        
+        return None
+    if not os.path.exists(filename):
+        print(f"File {filename} with labels of test samples is not found")
+        print("Accuracy of DNN on this test cannot be evaluated")
+        return None
+    labels = []
+    with open(filename, newline='') as csvfile:
+        test_reader = csv.reader(csvfile)
+        test_reader.__next__() #Skip csv header
+        for _num, _lbl in test_reader:
+            labels.append(int(_lbl))
+    return np.asarray(labels)
+
+def writePredictions(test, probabilities, filename):
+    """
+    Write down similarity predictions
+    Parameters:
+    - test           -- path to the testset file specifying pairs 
+                        of source code file to analyze similarity
+    - probabilities  -- numpy array with probabilities of similarities
+    - filename       -- filename to write predictions
+    """
+    with open(test, newline='') as csvin,\
+         open(filename, 'w', newline='') as csvout:
+        test_reader = csv.reader(csvin)
+        writer = csv.writer(csvout, lineterminator=os.linesep)
+        test_reader.__next__() #Skip csv header
+        writer.writerow(["pair-id", "file1", "file2",
+                         "confidence", "prediction"])
+        _i = 0
+        for _num, _fn1, _fn2 in test_reader:
+            writer.writerow([_num, _fn1, _fn2, probabilities[_i][0],
+                             "Similar" if probabilities[_i][0] >= 0.5
+                             else "Dissimilar"])
+            _i += 1
+    
+def main(args):
+    """
+    Main function of program for predicting similarity testset samples
+
+    Parameters:
+    - args  -- Parsed command line arguments
+               as object returned by ArgumentParser
+    """
+    if not os.path.exists(args.source_code):
+        sys.exit(f"Directory {args.source_code} with source code is not found")
+    if not os.path.exists(args.test):
+        sys.exit(f"File {args.test} with test pairs is not found")
+    if not os.path.exists(args.tokenizer):
+        sys.exit(f"Tokenizer {args.tokenizer} is not found")
+    if not os.path.exists(args.dnn):
+        sys.exit(f"Check point with dnn model {args.dnn} is not found")
+    ds = makeDataset(args.source_code, args.test, args.tokenizer)
+    labels = loadLabels(args.labels)
+    #Load trained DNN from TF checkpoint
+    dnn = tf.keras.models.load_model(args.dnn)
+    if labels is not None:
+        if ds[0].shape[0] == labels.shape[0]:
+            #Evaluate DNN accuracy on the testset
+            loss, acc = dnn.evaluate(ds, labels, verbose = args.progress)
+            print("\nEvaluation accuracy is {:5.2f}%".format(acc * 100))
+            print("Evaluation loss is {:5.2f}".format(loss))
+        else:
+            print(f"Numers of labels {labels.shape[0]} " +
+                f"and samples {ds[0].shape[0]} is different ")
+            print("Accuracy of DNN on this test cannot be evaluated")
+    #Compute probabilities of similarity predicted by DNN
+    prob = dnn.predict(ds, verbose = args.progress)
+    writePredictions(args.test, prob, args.predictions)
+##############################################################################
+# Program arguments are described below
+##############################################################################
+if __name__ == '__main__':
+    print("\nPREDICTING SIMILARITY OF TESTSET SAMPLES")
+    #Handle command-line arguments
+    parser = argparse.ArgumentParser("TestSetEval")
+    parser.add_argument("source_code", type=str,
+                        help="directory with source code files to analyze similarity")
+    parser.add_argument("test", type=str,
+                        help="file with sample pairs to analyze similarity")
+    parser.add_argument("--labels", type=str, default = None,
+                        help="file with similarity labels of test samples")
+    parser.add_argument("--dnn", default = "./dnn_ckpt",
+                        type=str, help="checkpoint file with trained dnn")    
+    parser.add_argument("--tokenizer", default = "tokenize",
+                        type=str, help="path to tokenizer of source code files")
+    parser.add_argument("--predictions", default = "./predictions.csv",
+                        type=str, help="file to write similarity predictions")
+    parser.add_argument("--batch", default=400, type=int,
+                        help="batch size")
+    parser.add_argument('--progress', default=1, type=int,
+                        choices=[0, 1, 2],
+                        help="mode of Keras training progress bar")
+    args = parser.parse_args()
+
+    print("Program arguments used:")
+    for k,v in sorted(vars(args).items()):
+        print("{}: {}".format(k,v))
+        
+    main(args)
+
+

Contest/ExampleSimAnalysis/test_eval.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+#Evaluating contest testset with DNN source code similarity analyzer:
+#Parameters:
+# $1  -- directory with source code files
+# $2  -- csv file with sample pairs to analyze
+# $3  -- csv file with ground truth labels
+DATA=$1
+TEST=$2
+TOKENIZER=/Volume1/AI4CODE/bin/tokenize
+DNN=dnn_ckpt
+if test $# -gt 2; then
+    echo "Evaluating DNN accuracy on test set"
+    python TestSetEval.py $DATA $TEST --labels $3 --tokenizer $TOKENIZER --dnn $DNN --predictions ./predictions_2.csv --batch 400
+fi
+echo "Computing predictions of source code similarity"
+python TestSetEval.py $DATA $TEST --tokenizer $TOKENIZER --dnn $DNN --predictions ./predictions_1.csv --batch 400

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,270 @@
+# Project CodeNet
+
+[![DOI](https://zenodo.org/badge/363800912.svg)](https://zenodo.org/badge/latestdoi/363800912)
+
+The goal of Project CodeNet is to provide the *AI-for-Code* research community with a large scale, diverse, and high quality curated dataset to drive innovation in AI techniques. 
+
+## Table of Contents
+
+   * [Introduction](#introduction)
+      * [Differentiation](#differentiation)
+      * [Benchmarks](#benchmarks)
+      * [Potential use cases](#potential-use-cases)
+      * [Usability](#usability)
+   * [Models and experiments](#models-and-experiments)
+   * [Relevant links](#relevant-links)
+   * [Download the dataset](#download-the-dataset)
+   * [Dataset overview](#dataset-overview)
+      * [Dataset statistics](#dataset-statistics)
+   * [Data](#data)
+   * [Metadata](#metadata)
+      * [Metadata at the dataset level](#metadata-at-the-dataset-level)
+      * [Metadata at the problem level](#metadata-at-the-problem-level)
+   * [Directory structure and naming convention](#directory-structure-and-naming-convention)
+   * [Relationships among the metadata and data](#relationships-among-the-metadata-and-data)
+      * [Example of getting the source file for a particular submission](#example-of-getting-the-source-file-for-a-particular-submission)
+      * [Example of getting the metadata for a particular source file](#example-of-getting-the-metadata-for-a-particular-source-file)
+   * [Tools to process source files](#tools-to-process-source-files)
+      * [Statistics](#statistics)
+      * [Access and selection](#access-and-selection)
+      * [Pre-processing](#pre-processing)
+   * [Contributors](#contributors)
+
+## Introduction
+
+A decade ago, Marc Andreessen [famously wrote](https://a16z.com/2011/08/20/why-software-is-eating-the-world/) that "software is eating the world." Software now permeates every part of our existence; Google services combine for [2 billion lines of code](https://www.wired.com/2015/09/google-2-billion-lines-codeand-one-place/), and a modern vehicle [contains around](https://www.technologyreview.com/2012/12/03/181350/many-cars-have-a-hundred-million-lines-of-code/) 100 million lines of code. It's a monumental challenge to create, debug, maintain, and update these complex software systems. Recently, a fast-growing discipline known as AI for Code aims to help software developers improve their productivity by automating the software engineering process. AI for Code researchers have been leveraging technologies like NLP and augmenting them with code analysis and compilation techniques to perform a myriad of practical tasks, such as code search, summarization, and completion, as well as code-to-code translation. The discipline isn't limited to academic research either: Ruchir Puri, IBM Research's chief research scientist, discussed in a recent [podcast](https://open.spotify.com/episode/7gHPbVBHEgSdrACTow7Gql) how technologies from AI for Code are being used to modernize legacy software by helping migrate monolithic applications to microservices for IBM's enterprise clients.
+
+AI for Code is poised to transition from proof-of-concept to widespread adoption. To provide a catalyst for such a tipping point, researchers at IBM Research have introduced Project CodeNet, a large-scale dataset for benchmarking and experimentation. Project CodeNet has many characteristics (large scale, diveristy, etc.) similar to ImageNet, a huge dataset for imagery that had a dramatic impact on the field of computer vision research. Project CodeNet is a large scale dataset with approximately 14 million code samples, each of which is an intended solution to one of 4000 coding problems. Project CodeNet aims to do for AI for Code what ImageNet did for computer vision.
+
+### Differentiation
+
+There are a few differentiating features of Project CodeNet when compared to other similar efforts. In addition to the size of the dataset, the code samples are written in over 50 programming languages, though the dominant languages are C++, C, Python, and Java. The code samples in Project CodeNet are annotated with a rich set of information, such as the code size, memory footprint, CPU run time, and status, which indicates acceptance or error types. Over 90% of the problems come with the respective problem description, which contains a concise problem statement, specification of the input format and the output format. When available, we also extracted from the problem description sample input and output, and provide them as part of the dataset. Users can execute the accepted codes samples (over 50% of the submissions are accepted) to extract additional metadata and verify outputs from generative AI models for correctness.
+
+Another area that Project CodeNet addressed is the quality of the data samples. From a [paper](https://arxiv.org/pdf/1812.06469.pdf) by Allamanis, we learned that quite a large number of frequently used AI for Code datasets have duplicate or near-duplicate code samples, which can inflate performance metrics as much as 100%. In addition, we found that problem-submission style datasets from online judging systems can contain clusters of identical problems, which will certainly skew the performance metrics. One example is [POJ-104](https://sites.google.com/site/treebasedcnn/), in which problems 26 and 62 are identical. Therefore we identified the near-duplicates and the identical problem clusters in Project CodeNet and provide these information for the benefit of the users.
+
+### Benchmarks
+
+In light of these issues, we have extracted several benchmark datasets from CodeNet for users to perform code classification and code similarity experiments. They have been filtered to remove identical problem clusters and near-duplicate code samples, so that performance metrics can be measured on training and test data samples with the appropriate statistics. There are two C++ benchmark datasets that are similar to the popular POJ-104 but are approximately ten times in size. We felt that the size increase is necessary, since [98% accuracy](https://github.com/zhangj111/astnn) has been already achieved in code classification on POJ-104. An order of magnitude larger dataset will leave ample room to advance the state of the art with more complex neural networks and algorithms. The other two benchmark datasets are in Python and Java, which provides a different flavor because the frequent use of library functions.
+
+### Potential use cases
+
+The rich metadata and diversity open Project CodeNet to a plethora of uses cases. The problem-submission relationship in Project CodeNet corresponds to [type-4 similarity](https://escholarship.org/uc/item/45r2308g) and can be used for code search and clone detection. The code samples in Project CodeNet are labeled with their acceptance status and we can explore AI techniques to distinguish correct codes from problematic ones. Project CodeNet's metadata also enables the tracking of how a submission evolves from problematic to accepted, which could be used for exploring automatic code correction. Each code sample is labeled with CPU run time and  memory footprint, which can be used for regression studies and prediction. Given  its wealth of programs written in a multitude of languages, Project CodeNet may serve as a valuable benchmark dataset for source-to-source translation.
+
+### Usability
+
+To facilitate creation of customized benchmarks and dataset, we provide a set of productivity tools to aggregate codes samples based on user criteria. We are also releasing pre-processing tools to transform code samples into [token sequences](tools/tokenizer), [simplified parse trees](tools/spt-generator) and other [code graphs](tools/analysis-graph-generator).
+
+## Models and experiments
+
+We have performed numerous experiments on the CodeNet dataset. The goal of these experiments is to produce a set of baseline models and results for users of the CodeNet dataset to gauge their research. The run scripts and training scripts are available in the model-experiments directory. The classification and similarity experiments use the benchmark datasets we extracted from CodeNet as training and test datasets. In addition to experiments based on token sequences, we also have experiments leveraging graph neural networks (GNN). For the convenience of the users interested in GNN's, we have included the simplified parse tree (SPT) representation of the code samples for each benchmark dataset. The experiment on Masked Language Model has a companion Jupyter notebook in the notebooks directory.
+
+## Problem Descriptions
+
+For the vast majority of problem classes, short problem descriptions are available in
+'doc/problem_descriptions.tar.gz', a small html file for each problem. 
+
+## Relevant links
+
+- [Project CodeNet full dataset: Project_CodeNet.tar.gz](https://codait-cos-dax.s3.us.cloud-object-storage.appdomain.cloud/dax-project-codenet/1.0.0/Project_CodeNet.tar.gz) (7.8GB)
+- Project CodeNet metadata: Project_CodeNet_metadata.tar.gz. Unfortunately this dataset is no longer available as a separate tar file;
+It does however form part of the full dataset listed above.
+- [Project CodeNet paper: Arxiv paper](https://arxiv.org/abs/2105.12655)
+
+## Download the dataset
+
+Download the full dataset from the link listed above, then use
+
+`tar -zxf Project_CodeNet.tar.gz`
+to uncompress and untar. The directory structure and how the code samples are organized are explained [here](README.md#directory-structure-and-naming-convention).
+
+The 4 benchmark datasets, Project_CodeNet_C++1000, Project_CodeNet_C++1400,
+Project_CodeNet_Python800, and Project_CodeNet_Java250 are included in the
+full dataset.
+They can be used for code classification and code similarity research as a replacement of or in addition to the dataset [POJ-104](https://sites.google.com/site/treebasedcnn/).
+
+## Dataset overview
+
+The Project CodeNet Dataset consists of a very large collection of source files, extensive metadata, tooling to access the dataset and make tailored selections, and documentation.
+
+The basis of the dataset is the data available on two online judge web sites:
+
+1. [AIZU Online Judge](https://onlinejudge.u-aizu.ac.jp/home)
+2. [AtCoder](https://atcoder.jp/)
+
+An online judge website offers programmers an opportunity to test their skills by posing programming problems in the form of courses or contests. Users may submit their solution which is then judged by an automatic review mechanism. The outcome is reported back to the user. Both problem descriptions, user submissions and associated metadata are available for study via various REST APIs.
+
+The first step in constructing Project CodeNet is downloading the problem descriptions and the source code submissions from the websites mentioned above, followed by reshaping and consolidating the metadata and cleaning up the inconsistencies, omissions, and
+mistakes in the source data itself.
+
+### Dataset statistics
+
+The dataset comprises 13,916,868 submissions, divided into 4053 problems (of which 5 are empty). Of the submissions 53.6% (7,460,588) are *accepted*, 29.5% are marked as *wrong answer* and the remaining suffer from one of the possible rejection causes. The data contains submissions in 55 different languages, although 95% of them are coded in the six most common languages (C++, Python, Java, C, Ruby, C#). C++ is the most common language with 8,008,527 submissions (57% of the total) of which 4,353,049 are *accepted*. Here are 2 pie charts depicting submissions and status distribution of Project CodeNet.
+
+<table><tr>
+<td> <img src="./assets/Project_CodeNet_subs.png" alt="Drawing" style="width: 250px;"/> </td>
+<td> <img src="./assets/Project_CodeNet_status.png" alt="Drawing" style="width: 250px;"/> </td>
+</tr></table>
+
+A detailed overview of the dataset statistics can be found in this [spreadsheet](assets/Project_CodeNet_statistics.xlsx).
+
+## Data
+
+The data consist of complete programs in a particular programming language. Each program is contained in a single file. The file will have a name with an extension that denotes the programming language used. (More details about the specific programming language and the version of the compiler/interpreter used, can be found in the metadata.)
+
+Each program attempts to solve a certain programming task or problem. There are many problems and each problem might have many solutions in different languages. We refer to each program as a submission instead of a solution since it might not be complete and correct.  Solutions are the accepted submissions that are compilable and executable, and at least correctly produce the expected results on all provided test cases. (Of course, according to the late Dijkstra, tests are no proof of correctness.)
+
+## Metadata
+
+The metadata provides properties of interest about the problems and their submissions. Foremost it formalizes the organization of the data and the relationship between problems, languages, and the source code files. The metadata allows for queries about the data and to make specific selections among the large collection of problems, languages, and source files.
+
+Metadata is made available in comma-separated value (CSV) files. This allows for easy processing, even with simple command-line tools. Some of the fields in the csv files might be empty, and for submissions that are not accepted, some fields might have invalid entries such as negative numbers for CPU time. Extra checking needs to be implemented in parsing these files.
+
+The metadata is hierarchically organized on 2 levels: the first level is the dataset level that relates to all the different problems defined by the various dataset sources. The second level is the problem level that relates to all source code submissions pertaining to a single problem or task.
+
+Metadata and data are deliberately kept fully separated within the file system.
+
+### Metadata at the dataset level
+
+At the dataset level there is a single CSV file (`problem_list.csv`) listing all the different problems. Additionally, for each problem there is a more extensive description that sets the problem and any further requirements and constraints and often provides examples of data input and expected output.
+
+The fields and their format of this CSV file are captured by the following table:
+
+name of column | data type | unit | description
+-- | -- | -- | --
+id           | string | none | unique anonymized id of the problem
+name         | string | none | short name of the problem
+dataset      | string | none | original dataset, AIZU or AtCoder
+time_limit   | int    | millisecond | maximum time allowed for a submission
+memory_limit | int    | KB | maximum memory allowed for a submission
+rating       | int    | none | rating, i.e., difficulty of the problem
+tags         | string | none | list of tags separated by "\|"; not used
+complexity   | string | none | degree of difficulty of the problem; not used
+
+### Metadata at the problem level
+
+At the problem level there is a CSV file per problem and all content of these files is of course organized under one and the same header.
+
+The fields and their format of this CSV file are captured by the following table:
+
+name of column | data type | unit | description
+-- | -- | -- | --
+submission_id | string | none | unique anonymized id of the submission
+problem_id    | string | none | anonymized id of the problem
+user_id       | string | none | anonymized user id of the submission
+date          | int    | seconds | date and time of submission in the Unix timestamp format (seconds since the epoch)
+language      | string | none | mapped language of the submission (ex: C++14 -> C++)
+original_language | string | none | original language specification
+filename_ext  | string | none | extension of the filename that indicates the programming language used
+status        | string | none | acceptance status, or error type
+cpu_time      | int    | millisecond | execution time
+memory        | int    | KB | memory used
+code_size     | int    | bytes | size of the submission source code in bytes
+accuracy      | string | none | number of tests passed; *Only for AIZU
+
+Here is a table of all the possible status values. The “abbreviation” and “numeric code” are sometimes seen in the original metadata on the websites; it is listed here for reference and completeness. These fields do not occur in the Project CodeNet metadata.
+
+status | abbreviation | numeric code
+-- | -- | --
+Compile Error          | CE  |  0
+Wrong Answer           | WA  |  1
+Time Limit Exceeded    | TLE |  2
+Memory Limit Exceeded  | MLE |  3
+Accepted               | AC  |  4
+Judge Not Available    | JNA |  5
+Output Limit Exceeded  | OLE |  6
+Runtime Error          | RE  |  7
+WA: Presentation Error | PE  |  8
+Waiting for Judging    | WJ  | 
+Waiting for Re-judging | WR  | 
+Internal Error         | IE  | 
+Judge System Error     |     | 
+
+## Directory structure and naming convention
+
+The data and metadata are organized in a rigorous directory structure. At the top level sits the `Project CodeNet` directory with several sub-directories, `data`, `metadata`, and `problem_descriptions`:
+
+- `data` is further subdivided into a directory per problem and within each problem directory, directories for each language. The language directory contains all the source files supposed to be written in that particular programming or scripting language. When there are no submissions for a particular language, there will be no directory for it, but the problem directory will always be there, even if there are no submissions at all.
+
+    The name of the directory for a programming language is the common name for the language using proper capitalization and special characters. This name is the consolidation of the names used in the metadata. Information is available about how the original language designations are mapped into the directory names and how these more general and common names are mapped to the submission file name extensions. As an example, a source could be designated c++14, which is mapped into the directory `C++` (notice the capital C) and will get the extension `.cpp`.
+- `derived` holds information about near-duplicates, identical problem clusters, sample input and output for each problem, as well as the benchmarks. 
+- `metadata` holds all the problem CSV files and the `problem_list.csv` file.
+- `problem_descriptions` holds HTML files for most problems, giving an extensive description of the problem, often accompanied with some sample input and expected output.
+
+For the sake of creating a uniform set of metadata across all data sources, and to hide any sensitive information, some metadata fields are anonymized by randomly (but uniquely and consistently) renumbering problem, submission, and user identifiers (ids). The identifiers we use are defined by simple regular expressions:
+
+- problem ids are anonymized and follow this pattern: `p[0-9]{5}` (a `p` followed by exactly 5 digits).
+- submission ids are anonymized and follow this pattern: `s[0-9]{9}` (an `s` followed by exactly 9 digits).
+- user ids are anonymized and follow this pattern: `u[0-9]{9}` (a `u` followed by exactly 9 digits).
+
+## Relationships among the metadata and data
+
+The main relationship between problem metadata and data is the fact that each metadata record (a non-header row in a problem CSV file) describes one source file and provides all information about its location. The directory structure and naming convention as stated above are implicitly assumed.
+
+### Example of getting the source file for a particular submission
+
+Starting at a CSV metadata entry for a particular submission, here is how to get to the corresponding source file. Say that the submission id is `s300682070`. Either we know this is a submission to problem `p00001` upfront or we can grep through all `Project_CodeNet/metadata/p?????.csv` files to learn that. We get a brief description of this problem by looking at the `p00001` entry in the `Project_CodeNet/metadata/problem_list.csv`:
+
+```console
+p00001,List of Top 3 Hills,AIZU,1000,131072,,,
+```
+
+We can get a more verbose description of this problem by reading `Project_CodeNet/problem_descriptions/p00001.html`.
+
+The `Project_CodeNet/metadata/p00001.csv` file provides the info on all submissions. For our selected submission we find:
+
+```console
+s300682070,p00001,u558442027,1480319506,JavaScript,JavaScript,js,Accepted,60,15496,219,4/4
+```
+
+We see it is an `Accepted` submission in the language `JavaScript` with file extension `.js`.
+
+The source file path therefore is: `Project_CodeNet/data/p00001/JavaScript/s300682070.js`
+
+### Example of getting the metadata for a particular source file
+
+Likewise, we can play the reverse game of finding the metadata entry for a given submission source file. Say the source file is `Project_CodeNet/data/p00001/JavaScript/s300682070.js`.
+
+Encoded in this file name path we see the problem id `p00001` and language `JavaScript` and of course the submission id `s300682070`. We find the metadata CSV file to be: `Project_CodeNet/metadata/p00001.csv`. Opening that file and searching for the submission id we find the entry:
+
+```console
+s300682070,p00001,u558442027,1480319506,JavaScript,JavaScript,js,Accepted,60,15496,219,4/4
+```
+
+## Tools to process source files
+
+The source files of Project CodeNet represent examples of some 50+ different programming and scripting languages. Of course not all languages are equally represented: most submissions are written in the more popular languages C, C++, Java, and Python.
+
+To complement our large dataset of source code, a suite of tools and utilities will be provided. These tools target several purposes:
+
+- derive statistics from the dataset
+- access the dataset files to make selections
+- preprocess the source files to extract certain information
+- facilitate conversions between popular formats
+
+### Statistics
+
+Since Project CodeNet uses the file system as storage and uses a rigorous directory structure, many (Linux) command-line utilities can be directly used to extract interesting statistics about the dataset. Utilities like `ls`, `wc` and `grep` are very useful. The CSV metadata can best be browsed using [`csvkit`](https://csvkit.readthedocs.io/en/latest/) components like `csvstat`.
+
+More elaborate statistics about the dataset can easily be retrieved using SQL queries on a database representation of the metadata. [HSQLDB](http://hsqldb.org/) is a database that runs off a CSV file. Our CSV problem metadata files are simply stripped of their headers and concatenated. A suite of useful SQL queries is available. A separate [document](doc/HSQLDB.md) explains the necessary steps.
+
+### Access and selection
+
+As described above, it should be easy to create specific subsets of the
+dataset merely by copying (or symlinking) relevant files and/or
+directories. For more elaborate selections based on a subset or range of
+problems, a subset of languages, statuses, and code sizes, several Bash
+scripts are available to accomplish that. These scripts reside in the
+`tools/aggregation-scripts` directory and are separately documented in this [README](tools/aggregation-scripts/README.md).
+
+### Pre-processing
+
+We provide tools to convert code samples into a representation that can be consumed by AI algorithms
+  - generate stream of tokens [tokenizer](tools/tokenizer)
+  - parsing to tree/abstract syntax tree [AST generation](tools/spt-generator) 
+  - control and data flow graph construction [code analysis](tools/analysis-graph-generator) 
+
+Whether and to what extent the above steps can successfully be applied to any given source file depends on several factors. Obviously, if the submission is not of `Accepted` status, it is to be expected that even simple tokenization will fail because of malformed lexical elements. But the situation for `Accepted` submissions is not always better: programmers might have used certain non-standard features of the language that happen to be accepted by a certain compiler or interpreter. Simple cases are the use of a dollar sign as part of a C identifier. For languages like C and C++ that use a pre-processor, use of macros and conditional defines can hugely change how the code ultimately looks like.
+
+### Contributors
+
+Ruchir Puri, David S. Kung, Geert Janssen, Wei Zhang, Giacomo Domeniconi, Vladimir Zolotov, Julian Dolby, Jie Chen, Mihir Choudhury, Lindsey Decker, Veronika Thost, Luca Buratti, Saurabh Pujar, Shyam Ramji, Ulrich Finkler, Susan Malaika, Frederick Reiss.

assets/Project_CodeNet_statistics.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47f56f9cc9dde3290b11e235770577390de9d38f4f6c08be86d0ca1a38dc239d
+size 185503

doc/HSQLDB.md

@@ -0,0 +1,267 @@
+# Access Project CodeNet through SQL Queries
+
+## Table of Contents
+
+   * [Introduction](#introduction)
+   * [Installation](#installation)
+   * [Creating a sqltool.rc file](#creating-a-sqltoolrc-file)
+   * [Prepare Project CodeNet for use with HSQLDB](#prepare-project-codenet-for-use-with-hsqldb)
+   * [Define the table schemas](#define-the-table-schemas)
+   * [A few simple SQL queries](#a-few-simple-sql-queries)
+
+## Introduction
+
+Project CodeNet metadata is available as CSV files in a rigid directory
+structure. To abstract away from this structure and the peculiarities
+of the metadata organization, we can use a database approach to the
+metadata that allows for generic SQL queries to retrieve all kinds of
+statistics but more importantly select file names of submissions
+depending on all kinds of criteria.
+
+One particular database is ideally suited to work with CSV files:
+[*HyperSQL Database* (HSQLDB)](http://hsqldb.org). HSQLDB uses the CSV
+files as persistent
+storage and uses memory caches to speed up the queries.
+
+HSQLDB is a simple but complete database software
+implemented in Java. The main attractive feature is that it can link to
+CSV files as tables and use them as persistent storage. This implies
+that SQL queries can directly run off existing (even read-only) CSV
+files without any modifications.
+
+## Installation
+
+Here we explain how to install and set up HSQLDB to work with the
+Project CodeNet dataset. We assume `$PREFIX` to be a suitable system directory
+like e.g. `/usr/local` and `$HOME` to expand to a user's home directory.
+
+This brief guide is in no way a substitute for the excellent and
+extensive [documentation](http://hsqldb.org/web/hsqlDocsFrame.html)
+and [howtos](http://hsqldb.org/web/howto.html) that accompany HSQLDB.
+
+We assume the use of (the latest as of writing) version 2.6.0 of HSQLDB.
+(Any future newer version will probably work just as well).
+
+The required software can be downloaded from
+<http://www.hsqldb.org/download/hsqldb_260_jdk8/>.
+That website offers the 2 files `hsqldb-2.6.0-jdk8.jar` and
+`sqltool-2.6.0-jdk8.jar`. Rename the files to
+`hsqldb.jar` and `sqltool.jar`, respectively.
+
+Important files and their use are:
+
+>`hsqldb.jar`
+: The jar file containing all classes of the database engine proper.
+Typically resides in some system accessible directory, like:
+`$PREFIX/lib/hsqldb-2.6.0/hsqldb/lib/`
+
+>`sqltool.jar`
+: The jar file that provides an interactive command-line user interface (CLI)
+to the database. Resides next to `hsqldb.jar`.
+
+>`sqltool`
+: A wrapper around `sqltool.jar` that calls the Java JVM and starts the
+CLI. Typically to be found in a `bin` directory, like `$PREFIX/bin/`.
+Its contents could be something like:
+```bash
+#!/usr/bin/env bash
+
+HSQLDB_HOME=$PREFIX/lib/hsqldb-2.6.0/hsqldb
+
+# allow csv to reside anywhere (and not just inside db directory)
+java -Dtextdb.allow_full_path=false -jar $HSQLDB_HOME/lib/sqltool.jar "$@"
+```
+
+>`sqltool.rc`
+The configuration file consulted by `sqltool`.
+To be located in the user's home directory, e.g.
+`$HOME/sqltool.rc`
+
+>`DatabaseManagerSwing`
+: A wrapper around `hsqldb.jar` that provides a graphical interface (GUI) to
+the database. Can be found in the same bin directory as `sqltool`.
+
+## Creating a `sqltool.rc` file
+
+This configuration file specifies the various databases via URLs and
+access rights. For simplicity we here assume a single user who is the
+database administrator using the default user name `SA` without a
+password. This is expressed as follows in `sqltool.rc`:
+
+```
+urlid .+
+username SA
+password
+```
+
+Assume we create the database (a collection of CSV files that become
+the database tables) in a directory `$HOME\DB`. This is made known to
+HSQLDB as follows and added to `sqltool.rc`:
+
+```
+urlid project_codenet
+url jdbc:hsqldb:file:${user.home}/DB/project_codenet;shutdown=true
+transiso TRANSACTION_READ_COMMITTED
+```
+
+Make sure that the directory exists: `mkdir -p $HOME/DB`.
+With the configuration file in place, we can test our set up so far by
+running `sqltool` and doing a few simple queries:
+
+```bash
+# Not really necessary, but for convenience, go to the DB directory:
+$ cd $HOME/DB
+
+# Start the sqltool program and make it use the (empty) project_codenet db:
+# (You will get a message and eventually the sql> prompt.)
+$ sqltool project_codenet
+SqlTool v. 6140.
+...
+sql> 
+```
+
+You can explore some of the commands and browse the system tables.
+Here are a few examples:
+
+```bash
+# Get help about \ commands:
+sql> \?
+# Get a list of user tables (result is none):
+sql> \dt
+# Get a list of system tables:
+sql> \dS
+# Get the list of known users (only 1: SA):
+sql> select * from information_schema.system_users;
+# Quit the program (\q or simply ^D in a Linux shell):
+sql> \q
+```
+
+This will leave behind the files `project_codenet.properties` and
+`project_codenet.script` in the `DB` directory. These are the files used by
+HSQLDB to record the database properties, the table schemas, etc.
+In general you should not delete them.
+
+## Prepare Project CodeNet for use with HSQLDB
+
+HSQLDB equates a database table with a CSV file. In Project CodeNet we have a
+CSV per problem which is not very convenient. It is better to merge
+all problem metadata (`p?????.csv`) into a single CSV file. Note
+however that each problem CSV has its own header; these need to be
+stripped off first. Since the dataset is read-only we must make a copy
+of the metadata directory. As an example we show the necessary steps:
+
+```bash
+# Make sure we are in the database directory:
+$ cd $HOME/DB
+
+# Copy the metadata from Project CodeNet:
+$ cp -r Project_CodeNet/metadata .
+
+# Move the problem_list out and rename:
+$ mv metadata/problem_list.csv problems.csv
+
+# Get a separate header file:
+$ head -n1 metadata/p00000.csv > submissions_header.csv
+
+# Strip off all headers:
+$ find metadata -type f -exec sed -i -e '1d' {} \;
+
+# Create a single CSV file:
+$ cat submissions_header.csv metadata/p?????.csv > submissions.csv
+
+# For safety make the CSV files read-only:
+$ chmod 444 problems.csv submissions.csv
+
+# The metadata copy and submissions_header are no longer needed:
+$ rm -rf metadata submissions_header.csv
+```
+
+Now we can create HSQLDB tables for `problems.csv` and `submissions.csv`.
+
+## Define the table schemas
+
+To create a database table we need to specify its columns, the type of
+value in each column and optionally some specific constraints or
+properties for that column. All this is specified in an SQL
+create table statement. Run `sqltool` and enter the following SQL statements
+to accomplish the table creation and linking to the corresponding CSV files:
+
+```bash
+$ cd $HOME/DB
+$ sqltool project_codenet
+```
+```sql
+sql> CREATE TEXT TABLE problems(
+    id            VARCHAR( 6)    PRIMARY KEY NOT NULL,
+    name          VARCHAR(64),
+    dataset       VARCHAR(16)    NOT NULL,
+    time_limit    INTEGER,
+    memory_limit  INTEGER,
+    rating        INTEGER,
+    tags          VARCHAR(64),
+    complexity    VARCHAR(32)
+);
+
+SET TABLE problems READ ONLY;
+
+SET TABLE problems SOURCE 'problems.csv;encoding=UTF-8;\
+cache_rows=50000;cache_size=10240000;ignore_first=true;\
+fs=,;qc=\quote';
+
+sql> CREATE TEXT TABLE submissions(
+    submission_id     VARCHAR(10)    PRIMARY KEY NOT NULL,
+    problem_id        VARCHAR( 6)    NOT NULL,
+    user_id           VARCHAR(10)    NOT NULL,
+    date              BIGINT         NOT NULL,
+    language          VARCHAR(16)    NOT NULL,
+    original_language VARCHAR(16)    NOT NULL,
+    filename_ext      VARCHAR(16)    NOT NULL,
+    status            VARCHAR(32)    NOT NULL,
+    cpu_time          INTEGER        NOT NULL,
+    memory            INTEGER        NOT NULL,
+    code_size         INTEGER        NOT NULL,
+    accuracy          VARCHAR(16)
+);
+
+SET TABLE submissions READ ONLY;
+
+SET TABLE submissions SOURCE 'submissions.csv;encoding=UTF-8;\
+cache_rows=50000;cache_size=10240000;ignore_first=true;\
+fs=,;qc=\quote';
+
+sql> commit;
+sql> \q
+```
+
+Note the `commit` command (abbreviated as `\=`); this is absolutely
+vital: it commits all the changes to the database. Without it all our
+effort would get lost as soon as we quit. The commit of the
+submissions table will take a while (maybe several minutes) because
+the large `submissions.csv` file has to be read and converted into an
+internal format. So be patient.
+
+## A few simple SQL queries
+
+```sql
+sql> -- How many distinct programming languages are used:
+sql> select count(distinct language) from submissions;
+
+sql> -- How many submissions per language:
+sql> select language, count(*) as nr_submissions
+       from submissions group by language
+       order by nr_submissions desc;
+
+sql> -- how many accepted submissions with code size >= 500 per language:
+sql> select language, count(*) as accepted_submissions
+       from submissions
+       where status = 'Accepted' and code_size >= 500
+       group by language order by accepted_submissions desc;
+
+sql> -- How many problems with >= 200 accepted submissions per language:
+sql> select language, count(*) as problems
+       from (select problem_id, language, count(*) as accepted
+               from submissions where status = 'Accepted'
+               group by problem_id, language
+               having count(*) >= 200)
+       group by language order by problems desc;
+```

doc/README.md

@@ -0,0 +1,32 @@
+# Documentation on Tools
+
+## Introduction
+
+This directory contain detailed documentation on various tools that
+can be used to manipulate the source files available in the Project CodeNet
+dataset.
+
+It also contains working documents on proposals and ideas for tools,
+formats, and applications.
+
+## HSQLDB
+
+HSQLDB is a simple but complete database software that can use CSV files as
+persistent storage. This [document](./HSQLDB.md) describes how to convert the
+Project CodeNet metadata to be used with HSQLDB.
+
+## srcml
+
+srcML is a tool for the analysis of programming language source code.
+The [document](./srcml.md) describes typical use cases.
+
+## Syntax-correct Tokenstream
+
+It is possible to obtain a token (class) stream from a source code file such
+that the result is still syntactically correct. This
+[document](./syntax-correct-tokenstream.md) shows how.
+
+## Universal Tokens
+
+Some thoughts and a proposal to normalize the token classes for various
+programming languages are presented [here](./universal_tokens.md).

doc/problem_descriptions.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b631ae168ba84dce69c7d8e1b6c632256e0155858c2664c6493a5f001b45fdd
+size 3492211

doc/srcml.md

@@ -0,0 +1,245 @@
+# Some Experiments using the srcML Tool
+
+## Introduction
+
+[srcML](https://www.srcml.org) is a tool for the analysis of programming
+language source code.
+It is unique in that it presents its results in the form of an annotation
+(using XML elements and attributes) of the original source code in a lossless
+manner. Like in compression, lossless here means that the original source code
+can be fully retrieved, inclusive lay-out in the form of white-space
+and indentation.
+
+The provided annotation reflects a simple Abstract Syntax Tree (AST) of the
+"program". The program need not necessarily be a complete program in the sense
+of the syntax of the programming language; it might as well be a well-formed
+code snippet, like a declaration, a function definition, or a block of
+statements, or an expression. Unlike with other parsers that would need to
+know a grammar start symbol, with srcML there is no need to make this known:
+srcML will figure out by itself how to process the snippet.
+The programming languages supported by srcML are: C, C++, C#,
+and Java. Each language has its own unique XML elements together with a common
+shared set for similar language constructs.
+This is documented [here](https://www.srcml.org/doc/srcMLElements.html).
+
+### Example
+
+The XML annotation is demonstrated here with a tiny C source code example:
+
+[tiny.c]
+```C
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  printf("args: %d\n", argc);
+  return 0;
+}
+```
+
+The following command turns the C code into the annotated XML:
+```console
+$ srcml tiny.c -o tiny.xml
+```
+
+This generates the following XML. Mind that we manually edited the result
+so that it fits on the page in this document without truncation of long lines.
+(Of course this destroys the preserved lay-out of the original C source.)
+
+```xml
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<unit xmlns="http://www.srcML.org/srcML/src"
+	  xmlns:cpp="http://www.srcML.org/srcML/cpp"
+	  revision="0.9.5" language="C" filename="tiny.c">
+  <cpp:include>#<cpp:directive>include</cpp:directive>
+    <cpp:file>&lt;stdio.h&gt;</cpp:file>
+  </cpp:include>
+
+<function><type><name>int</name></type> <name>main</name>
+  <parameter_list>(<parameter><decl><type><name>int</name></type>
+    <name>argc</name></decl></parameter>,
+	<parameter><decl><type><name>char</name> <modifier>*</modifier></type>
+	<name><name>argv</name><index>[]</index></name></decl></parameter>
+  )</parameter_list>
+
+<block>{
+  <expr_stmt><expr><call><name>printf</name>
+    <argument_list>(
+	<argument><expr><literal type="string">"args: %d\n"</literal></expr>
+	</argument>,
+	<argument><expr><name>argc</name></expr></argument>
+	)</argument_list></call></expr>;</expr_stmt>
+  <return>return <expr><literal type="number">0</literal></expr>;</return>
+}</block></function>
+</unit>
+```
+
+To restore the original C code, run this:
+```console
+$ srcml tiny.xml
+```
+
+To remove the enclosing `<unit>` element use the `--output-srcml-inner` option.
+To render the output XML in a nicely formatted form you can use this filter:
+`| tidy -xml -i -q -`.
+(Obviously you will lose the original white-space lay-out.)
+
+There are various tools to render the parse tree as an image. A simple one is
+DrawTag that accept any XML as input.
+See figure 1 for a visualization of the tiny.xml file.
+
+![srcml XML output rendered as a tree.](../assets/tiny.png)
+
+The srcML program has many options:
+
+```console
+GENERAL OPTIONS:
+  -h [ --help ] arg                 display this help and exit. USAGE: help or 
+                                    help [module name]. MODULES: src2srcml, 
+                                    srcml2src
+  -V [ --version ]                  display version number and exit
+  -v [ --verbose ]                  conversion and status information to stderr
+  -q [ --quiet ]                    suppress status messages
+  --list                            list all files in the srcML archive and 
+                                    exit
+  -i [ --info ]                     display most metadata except srcML file 
+                                    count and exit
+  -L [ --longinfo ]                 display all metadata including srcML file 
+                                    count and exit
+  --max-threads arg (=4)            set the maximum number of threads srcml can
+                                    spawn
+  -o [ --output ] arg (=stdout://-) write ouput to a file
+
+
+CREATING SRCML:
+  -l [ --language ] arg               set the language to C, C++, or Java
+  --register-ext arg                  register file extension EXT for 
+                                      source-code language LANG. arg format 
+                                      EXT=LANG
+  --src-encoding arg                  set the input source encoding
+  --files-from arg                    read list of source file names to form a 
+                                      srcML archive
+  -X [ --output-xml ]                 output in XML instead of text
+  -r [ --archive ]                    store output in a srcML archive, default 
+                                      for multiple input files
+  --in-order                          enable strict output ordering
+  -t [ --text ] arg                   raw string text to be processed
+
+MARKUP OPTIONS:
+  --position                          include line/column attributes, namespace
+                                      'http://www.srcML.org/srcML/position'
+  --tabs [=arg(=8)]                   set tabs arg characters apart.  Default 
+                                      is 8
+  --cpp                               enable preprocessor parsing and markup 
+                                      for Java and non-C/C++ languages
+  --cpp-markup-if0                    markup cpp #if 0 regions
+  --cpp-nomarkup-else                 leave cpp #else regions as text
+
+XML FORM:
+  -x [ --xml-encoding ] arg (=UTF-8)  set output XML encoding. Default is UTF-8
+  --no-xml-declaration                do not output the XML declaration
+  --no-namespace-decl                 do not output any namespace declarations
+  --xmlns arg                         set the default namespace to arg
+  --xmlns: arg                        set the namespace. arg format PREFIX=URI
+
+METADATA OPTIONS:
+  -f [ --filename ] arg               set the filename attribute
+  --url arg                           set the url attribute
+  -s [ --src-version ] arg            set the version attribute
+  --hash                              add hash to srcml output
+  --timestamp                         add timestamp to srcml output
+  -p [ --prefix ] arg                 display prefix of namespace given by URI 
+                                      arg and exit
+  --show-language                     display source language and exit
+  --show-url                          display source url name and exit
+  --show-filename                     display source filename and exit
+  --show-src-version                  display source version and exit
+  --show-timestamp                    display timestamp and exit
+  --show-hash                         display hash and exit
+  --show-encoding                     display xml encoding and exit
+  --show-unit-count                   display number of srcML files and exit
+
+
+EXTRACTING SOURCE CODE:
+  -S [ --output-src ]    output in text instead of XML
+  --to-dir arg           extract all files from srcML and create them in the 
+                         filesystem
+
+TRANSFORMATIONS:
+  --apply-root           apply an xslt program or xpath query to the root 
+                         element
+  --relaxng arg          output individual units that match RELAXNG file or URI
+  --xpath arg            apply XPATH expression to each individual unit
+  --xslt arg             apply XSLT file or URI transformation to each 
+                         individual unit
+  --attribute arg        add attribute to xpath query
+  --element arg          add element to xpath query
+  -U [ --unit ] arg      extract individual unit number from srcML
+```
+
+For instance, the XML markup can be enhanced with line and column coordinates.
+Notice also that srcML has built-in capabilities to query and manipulate the
+XML. Queries can be done with XPath expressions. General transformations can
+be executed with XSLT. By the way, there is no need to first convert the
+source to XML; the built-in queries capabilities work also directly off the
+source code.
+
+Here are a few examples of useful operations:
+
+- Get all function and method definition names:
+```console
+$ srcml --xpath="//src:function/src:name" program.java
+```
+
+- Count the number of conditions:
+```console
+$ srcml --xpath='count(//src:condition)' program.c
+```
+
+- Output all line comments:
+```console
+$ srcml --xpath='//src:comment[@type="line"]' program.cpp
+```
+
+Much more versatile and powerful tools to process any XML are
+[`xidel`](http://videlibri.sourceforge.net/xidel.html) and
+[`xmlstarlet`](http://xmlstar.sourceforge.net/).
+
+If you prefer JSON over XML, then use `jtm` to convert the srcML output:
+
+```console
+jtm -i2 tiny.xml > tiny.json
+```
+
+## Using srcML to extract a Function Call Graph
+
+A neat application of the combination of srcML and xmlstarlet is to use
+them in a script to produce the call graph of a program as a
+JSON-Graph.
+It is easy to extract the actual function
+definitions, i.e., the source text, of all functions mentioned in the
+call graph.
+
+Here we briefly sketch the main steps. Details can be found in the
+actual Bash scripts provided in [this](../tools/aggregation-scripts) directory.
+
+1. We start with using srcML to get all function definitions from a
+source file: (This will ignore any pre-processor directives, any global
+variables, and typedefs.)
+`srcml --xpath="//src:function" source.c -o source.xml`
+
+2. Given the `NAME` of a function we then look up its definition in the
+`source.xml` file and using `xmlstarlet` retrieve all names mentioned in
+function calls present in the body of that function definition:
+`xmlstarlet -t -v "//function[name=\"NAME\"]//call/name" source.xml`
+
+3. Using the capability of step 2, starting from some root function
+name supplied by a cmdline argument or defaulting to `main` we build a
+graph of nodes that represent functions and directed edges that
+represent the function calls.
+
+Notice that the call graph can have cycles. These are caused by direct
+recursive or mutual recursive functions.
+Once we have the graph, traversing it in reverse depth-first
+order enumerates all function definitions in the proper
+define-before-use order and can hence be retrieved from the
+`source.xml` file, again using srcML to convert them back to source code.

doc/syntax-correct-tokenstream.md

@@ -0,0 +1,209 @@
+# A Syntactically Correct Token Stream
+
+## Introduction
+
+With some ingenuity in terms of defining token classes and the symbols that
+represent them, it is possible to tokenize source code input of certain
+programming languages such that the token stream itself is a syntactically
+correct program. By the latter we mean that the token stream can be correctly
+parsed as a sentence of the language grammar. Of course, all semantic aspects
+such as use of identifiers (uniquely declared within a scope), application of
+operators to the correctly typed values, etc. are no longer valid.
+
+Apart from being an interesting curiosity,
+being syntactically correct makes it possible to read the program as a
+template: the complete grammatical structure is still clearly present,
+especially if we present the tokenized program text in a pretty-printed form.
+
+The following sections will show the details of the tokenization process as
+applied to the programming language C. It should be obvious how a similar
+approach can be developed for most imperative programming languages such as
+C++, Java, and Python (pretty-printing Python might be a bit of a challenge).
+
+## Approach
+
+So how can we tokenize C source code in such a way that the result is still
+syntactically correct?
+
+The trick to achieve this is to choose the right representative for each
+token class, i.e., the symbol used to designate a certain token class is a
+correct literal that belongs to that token class, a representative.
+Instead of the usual class names like number, operator, punctuator,
+we choose representative literals for those classes.
+
+Another subtle detail is to choose the least number of representatives of
+operators to ensure that expressions and other constructs involving operators
+will remain syntactically correct after the transformation. To represent any
+operator we therefore choose the asterisk symbol (`*`) which can either be
+used as a unary or an infix operator and moreover allows pointers to be
+correctly declared. Unfortunately, replacing all minus signs (`-`) with `*`
+might lead to errors in case of negative numbers, hence we make an exception
+of it and will add the minus sign as an additional explicit operator token.
+All other operators are not further distinguished (they all appear as `*`).
+
+For strings and character literals we make sure that their representatives do
+not contain a space character. As is commonly the case, we reserve the space
+character as the separator between tokens. That way simply splitting the input
+at white-space can fully reconstruct the individual tokens when needed.
+
+Putting all tokens on a single line might cause problems for certain tools
+that have some input line length limit. Moreover, the C pre-processor
+directives are not free-format and require to be put on a single (logical)
+line. To overcome this problem one could simply discard all pre-processor
+directives or have the tokenizer respect newlines. It depends on the back-end
+processing which solution is to be desired.
+
+## Token class definitions
+
+Here we define the various token classes and suggest a representative for
+each. On the outset we require that the vocabulary of all tokens is closed,
+i.e., we prefer a fixed set of token instances. For that reason we let every
+keyword represent itself since their class is closed. We will distinguish
+between user identifiers and standard identifiers. The former will
+collectively be represented by a single class element, say `id`. The latter
+must be one of a large set of over 300 names of functions and standard
+variables defined by a typical collection of C header files residing in
+`/usr/include` and also includes C pre-processor names like `include`,
+`define`, `ifdef`, etc. We assume that programmers will not use any of the
+standard identifiers for purposes other than their intended meaning,
+although this is not in any way required by the language.
+
+The following table summarizes the set of token representatives.
+
+|Representative:           | Represents:
+|--------------------------|-----------
+| `strcpy`, `malloc`, etc. | the standard identifiers (over 300)
+| `id`                     | any identifier
+| `[ ] ( ) { } < >`        | any of these punctuators
+| `; ? : :: , . ...`       | any of these punctuators (`::` only for C++)
+| `=`                      | any assignment operator (`+=`, `*=`, etc.)
+| `++ --`                  | auto-increment, auto-decrement
+| `-`                      | exception to better handle negative numbers
+| `*`                      | any other operator (`*` covers more cases than `+`)
+| `0`                      | the number `0`
+| `1`                      | the number `1`
+| `123`                    | any integer number except `0` and `1`
+| `3.14`                   | any floating-point number
+| `""`                     | any string literal
+| `'A`'                    | any character literal
+| `#`                      | the preprocessor symbol `#`
+| `##`                     | the preprocessor symbol `##` (very rare)
+
+## Example
+
+We will now demonstrate the tokenization of a small C program using the above
+suggested scheme. As an example we use the following complete and compilable C
+program (`test1.c`) that exhibits many of the different token types.
+
+```C
+#include <stdio.h>
+
+#define N 10
+
+/* Compute factorial recursively. */
+static int factorial(int i)
+{
+  if (i == 0)
+    return 1;
+  else
+    return i * factorial(i - 1);
+}
+
+int main(int argc, char *argv[])
+{
+  fprintf(stdout, "fac(%d) = %d\n", N, factorial(N));
+  return 0;
+}
+```
+
+We tokenize this to CSV format. To save space we only show the first 20 lines
+of output: from `tokenize -m csv test1.c`:
+
+```CSV
+line,column,class,token
+1,0,preprocessor,#
+1,1,identifier,include
+1,9,operator,<
+1,10,identifier,stdio
+1,15,operator,.
+1,16,identifier,h
+1,17,operator,>
+3,0,preprocessor,#
+3,1,identifier,define
+3,8,identifier,N
+3,10,integer,10
+6,0,keyword,static
+6,7,keyword,int
+6,11,identifier,factorial
+6,20,operator,(
+6,21,keyword,int
+6,25,identifier,i
+6,26,operator,)
+7,0,operator,{
+8,2,keyword,if
+```
+
+This output is then filtered by a simple AWK script (`filter5.awk`) to turn it
+into a stream of the above defined token classes. Here we will use `\` to
+indicate line continuations; these are not present in the actual output though.
+
+```console
+# include < id . id > # define id 123 static int id ( int id ) { if \
+( id * 0 ) return 1 ; else return id * id ( id - 1 ) ; } int main ( \
+int argc , char * argv [ ] ) { fprintf ( stdout , "" , id , id ( id \
+) ) ; return 0 ; } 
+```
+
+Unfortunately, the C pretty-printer that we use, is not able to correctly
+handle the token stream on a single line because of the pre-processor
+directives. Our tokenizer however is able to preserve newlines. So using that
+option we get the following filtered token stream (`test1.toks`):
+
+```console
+$ tokenize -n -m csv test1.c | ./filter5.awk -v ORS=" "
+# include < id . id > 
+
+# define id 123 
+
+
+static int id ( int id ) 
+{ 
+if ( id * 0 ) 
+return 1 ; 
+else 
+return id * id ( id - 1 ) ; 
+} 
+
+int main ( int argc , char * argv [ ] ) 
+{ 
+fprintf ( stdout , "" , id , id ( id ) ) ; 
+return 0 ; 
+} 
+```
+
+Now this output can easily be pretty-printed to this:
+
+```C
+# include < id . id > 
+
+# define id 123 
+
+static int id (int id)
+{
+    if (id * 0)
+        return 1;
+    else
+        return id * id (id - 1);
+}
+
+int main (int argc, char *argv [])
+{
+    fprintf (stdout, "", id, id (id));
+    return 0;
+}
+```
+
+# Conclusion
+
+A tokenizer followed by a simple AWK filter can render a token stream that
+when pretty-printed resembles a template for the original source code.

doc/universal_tokens.md

@@ -0,0 +1,215 @@
+# Proposal, considerations and rationale for a "Universal tokenizer output stream specification"
+
+## What is a tokenizer?
+
+A tokenizer is a procedure usually implemented as a computer program that
+splits an input text in smaller pieces that have a certain significance. One
+typical application is to split a sentence in its constituting words and
+punctuation symbols. In the realm of programming languages a tokenizer is used
+by almost every compiler and interpreter to split the input program text in
+chunks that make up the atomic terminal symbols of the language grammar.
+These chunks are called tokens.
+There are 2 broad classes of tokens
+
+1. tokens with a fixed prescribed representation
+2. tokens that are defined by rules (e.g. by a regular expression)
+
+The former class typically consists of operator symbols and reserved words;
+the latter class allows for user-defined identifiers and the notation of
+specific numeric constants and string literals.
+
+## Purpose of tokens
+
+The main purpose of tokens depends on the application. A compiler or
+interpreter typically would be happy with a stream of tokens that ignores all
+white-space and comments in the input text. Other uses might prefer to keep
+the comments. For instance a syntax highlighting program would use a
+particular font and color to render comments.
+
+So the first question is: do we discard white-space and comments or not?
+A troubling aspect of comments is that it includes block comments that can
+stretch over several physical input lines. A token output format (to be
+discussed in more detail below) can thus not be simply line based in that case.
+
+A nice and preferred aspect of the definition of a token would be that its
+literal text string fits on a single line of output irrespective of the actual
+output format chosen. For instance XML has no problem with multi-line text;
+in contrast JSON strings must fit on a single line but allow for embedded
+escaped newlines.
+
+So an important second question is: do we enforce that tokens are output 1 per
+line?
+
+This is convenient for many Unix text utilities that process their input line
+by line.
+
+## Aspects of tokens
+
+One way of proceeding is to look at how each supported programming language
+defines its tokens and try to find a common intersection of token classes.
+Here we work from the other end, and first look at some general aspects that
+we might like to know about the tokens.
+
+What are aspects of a token (assume we already have precise definitions) that
+could be of general interest:
+
+1. Obviously we want to know the literal token text itself.
+2. Although maybe redundant, the length in bytes of the token text could be
+   useful.
+3. Some indication of the location of the token in the text is deemed useful.
+   These coordinates could be an absolute position, or a (line,column)
+   combination, or both.
+4. A classification of the token in a category (token class).
+
+Additionally some more context could be of use, like
+
+5. What is the name of the source file, and 
+6. explicit token stream begin and end indicators when multiple files are
+   processed.
+7. We may even go beyond the lexical level: the same token literal
+   may be used in different contexts, with different meanings. Think of
+   `*` as the multiplication operator and `*` as the _pointer-to_
+   symbol in a type definition. Should the token class convey these
+   distinctions? Are we willing to fully parse the source input to
+   derive these semantic annotations?
+
+### token classes
+
+Here we assume that a token class is defined at the lexical level;
+there is no need to know the grammar of the language and do a parse to
+derive this classification.
+Some reasonable token class names, used and applicable across many languages
+are:
+
+- identifier
+- reserved word/keyword (does not include standard functions etc.)
+- number (lump all numbers together?), or split up like:
+  * integer number (no fraction; make distinction on notation?)
+  * floating-point number
+- single quoted (character) literal (at least 1 character?)
+- double quoted (string) literal
+- operator
+  * punctuation (hard to distinguish from operator sometimes)
+- language-specific special tokens like # and ## for CPP in C/C++
+
+Suggestion for generic token class names:
+
+| Class:       | Description:
+|--------------|------------
+| identifier   | any identifier
+| keyword      | a reserved word
+| integer      | integer number irrespective of notation
+| floating     | a floating-point number
+| string       | a double-quoted string (maybe empty)
+| character    | a single-quoted character (or string)
+| operator     | any symbol used to operate on values
+| punctuator   | any  symbol used for punctuation
+| preprocessor | either # or ##
+| filename     | pseudo token: start of a new file
+| newline      | pseudo token: end of logical line
+
+Quite often, too much specialization will be hard to undo;
+additional specialization will be easy to implement by some post-processing
+filter program using sed or awk.
+For instance,
+identifiers can be checked against a list of standard function names and
+hence separated in these and user identifiers.
+Operator symbols are easily grouped in various sub-classes like arithmetic,
+logical, relational, etc. or just unary and binary. But the roles of
+some symbols cannot be correctly distinguished without proper semantic
+annotation, e.g.. the symbol `<` could be part of a template
+definition in C++ or merely the less-than operator.
+
+Suggestion for a set of punctuator symbols:
+```console
+[ ] ( ) { } . , ? : :: ; ... @
+```
+
+Suggestion for a set of operator symbols:
+```console
+-> ->* .* ++ -- * / % + - << >>
+== != < > <= >= <=>
+~ ! | || & && ^
+=  *= /= %= += -= <<= >>= >>>= &= ^==
+```
+
+## Output formats
+
+An important guideline for the choice of an output format is its flexibility
+of use. The output should be easy to post-process preferable by standard
+open-source tools. We identify 3 formats that come to mind and fit the bill:
+
+1. **CSV**: simple line-based format that is easily parsed by many available
+utilities like `csvkit`. Requires that we have the same number of fields per
+token of course. Mind that we need to observe the definition of quoted text in
+CSV and encode tokens accordingly. This is something we need to do for most
+other formats too.
+2. **JSON**: very popular and not line-based.
+3. **XML**: diminishing popularity but a solid and standardized format.
+
+Both JSON and XML are very flexible and also offer the possibility of
+validating the format against a schema. Both are of course much more verbose
+than simple CSV.
+
+Many tools use a proprietary format that is tailored to their needs.
+Examples are Python's syntax highlighter
+[pygmentize](https://pygments.org/docs/tokens/#module-pygments.token)
+and the [ANTLR4](https://www.antlr.org/api/Java/org/antlr/v4/runtime/Token.html) lexer tokens output format.
+
+## Proposal for CSV
+
+Every token will occupy one CSV record, i.e., one physical line.
+The various fields are separated by commas. Care has to be taken to
+escape special characters: a comma itself has to be enclosed in double
+quotes; double quoted strings must have their double quotes doubled.
+
+Header: `line,column,class,token`
+
+## Proposal for JSON
+
+If we choose to represent each token on a single line, it is best to adopt the
+JSON Lines specification, i.e., have a single JSON object per line. Officially
+such a file is not valid JSON, but each line is.
+
+Object keys: `line`, `column`, `class`, `token`
+
+A more compact but less descriptive alternative is to simply use an
+array per token with a fixed number of assigned elements. For instance
+the first element would be the line number, the second the column
+number, the third the token class and the fourth the token string.
+
+## Proposal for XML
+
+In XML we have the option of storing data in either attributes of elements or
+as the text contents of the element. Simple-typed data is best stored as
+attributes. Free text and longer strings should become the text node of an
+element. It makes sense to have an element per token and collect all token
+elements under some root element.
+
+Elements: `<tokens>`, `<token>`
+
+Attributes: `line`, `column` `class`
+
+## Question summary
+
+- output white-space and comments or not?
+- continue in case of errors or not?
+- what format to use? all on single line?
+- what character encoding to use?
+- distinguish operator and punctuation symbols?
+- several (a hierarchy of) operator classes?
+- annotate with semantic information gleaned from parse tree?
+- distinguish integer and floating-point numbers?
+- even further distinction in octal, decimal, hexadecimal?
+- absolute position, line/column, or both?
+- apart from token literal, class, and coordinates anything else?
+
+## References
+
+> <a id="1">[1]</a>
+[Tokenizers: How machines read](https://blog.floydhub.com/tokenization-nlp/)
+
+> <a id="2">[2]</a>
+Daniel P Delorey, Charles Knutson, Mark Davies,
+[Mining Programming Language Vocabularies from Source Code](https://www.researchgate.net/publication/228825985_Mining_Programming_Language_Vocabularies_from_Source_Code),
+December 2008

metadata/Project_CodeNet.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae987bdcff5bda069fe7fedd8509da9ce5a2c213692a6dbf714d378be8f6177c
+size 323

model-experiments/gnn-based-experiments/.gitignore

@@ -0,0 +1,140 @@
+__pycache__/
+build/
+dist/
+*.egg-info/
+dataset/
+*.swp
+*.vscode
+*.DS_Store
+*.pt
+*.so
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

model-experiments/gnn-based-experiments/README.md

@@ -0,0 +1,89 @@
+# Graph Neural Network Baseline Experiments on Project CodeNet
+
+The goal of this project is to investigate the source code classification capabilities of standard graph neural networks (GNNs).
+We use the (slightly adapted) training procedures and models provided by the Open Graph Benchmark [1] with the example experiments on source code. 
+The code contains two GNNs, GCN [2] and GIN [3], including their extensions with virtual nodes.
+## Example
+
+### Graph Representation of Source Code
+
+![](./img/spt_augmented.png)
+
+We transform the source code into graphs as in the picture, where the **simplified parse tree (SPT)** (see Section 6 [in the paper](./../../ProjectCodeNet.pdf)) is extended by **next-token edges**.
+Each node is represented by five features: 
+(1) node type (token or parsing rule); 
+(2) token type (e.g., an identifier); 
+(3) parsing rule type (e.g., an expression); 
+(4) whether it represents a reserved word; and
+(5) its depth in the tree.
+
+Note that we actually consider the graph edges to be bi-directional at runtime in order to improve the learning capabilities of our models.
+
+### Graph Representation Learning
+
+**Graph neural networks (GNNs)** learn a graph representation by exploiting the graph structure as inductive bias. 
+Most GNNs follow the architecture proposed in [4]. In a nutshell, they first compute a node representation for every graph node by iteratively **aggregating** its neighbor nodes and **combining** this aggregated representation with the current node representation.
+Then, the node representations are **pooled** to obtain a final representation for the entire graph. 
+The different models vary primarily in the way they do the aggregation, combination, and pooling.
+
+The code contains two popular GNNs: 
+the **graph convolutional network (GCN)** [2], one of the first and most common GNNs, 
+and the **graph isomorphism network (GIN)** [3], which is more powerful since it pools not only the final node representations but those from all iterations. 
+In addition, we provide the **option for using virtual nodes**, which means that an artificial node is added to each graph and bi-directionally connected to all graph nodes to improve the aggregation phase. 
+
+Finally, note that you can easily integrate any graph classification model written in Pytorch Geometric. For an introduction to Pytorch Geometric, see [here](https://pytorch-geometric.readthedocs.io/en/latest/notes/introduction.html).
+
+
+### The Task
+
+In our experiments, we do program classification as follows.
+Each problem in the Project Codenet benchmark is one class, 
+and a code sample belongs to a class if it is a submission to the corresponding problem.
+Hence, **we use the graph representation of a code sample computed by the GNN to predict its problem class**.
+
+## Installation
+
+Tested with Python 3.8, PyTorch 1.8.1, and PyTorch Geometric 1.6.3.
+- Set up an Anaconda environment: `./setup.sh`
+(before running, edit pytorch installation command and set variables; see comment in file)
+- Alternatively, install the above and the packages listed in requirements.txt
+
+## Data
+
+The project contains a self-contained data sample directory  `small` to test the installation. Note that `small` directory contains two sub-directories `raw` and `splits/random`. The `raw` directory contains the SPT data (8 CSV files each in .gz format) and `splits/random` directory contains the training/validation/testing split files (in both CSV and its .gz format). We also published the splits files that we used in our paper [here](https://github.com/IBM/Project_CodeNet/blob/main/ProjectCodeNet_NeurIPS2021.pdf). To repeat the large scale JAVA/Python/C++ experiments as mentioned in the paper, one simply needs to download the Project CodeNet benchmark SPT datasets in graph format [here](https://developer.ibm.com/exchanges/data/all/project-codenet/) (e.g., Project_CodeNet_Java250_spts.tar.gz, which contains 8 CSV files that represent the encoding of the SPT graph) and convert each CSV file to its .gz format and put them into the corresponding data directory (e.g., data/Java250/raw) before launching the run script. Please refer to `small` directory for the file format and directory layout.  
+
+## Experiments
+
+* The script to run the experiments is `./run.sh`
+* By default, the script will run `GCN` over `small`. To change these settings, see the comments in the script. To repeat the JAVA/Python/C++ experiments as mentioned in our paper, one just needs to put the raw data in the corresponding directory (see above) and change the `DATASET` to one of the 4 options: Java250, Python800, C++1000, and C++1400.
+* You can change the dataset, data directory, and other variables in the script as needed.
+* Note that we did not do hyperparamter tuning. For all our experiments, we used the parameters from the script. 
+* When running the first time with a new dataset, the code will first preprocess the data. It will reuse these files with later runs.
+
+## Results
+
+
+|     | Java250 | Python800 | C++1000 | C++1400 |
+| ----| --------|--------   |-------  | --------|
+|    MLP w/ bag of tokens|71.87 | 67.84| 68.23 | 64.73 |
+ |   CNN w/ token sequence | 90.96 | 89.49| 94.27| 94.10 |
+  |  C-BERT                | 97.60| 97.30 | 93.00 | 90.00 |
+   | **GCN**           | 92.70 ± 0.25 | 93.82 ± 0.16 | 95.76 ± 0.12 | 95.26 ± 0.13|
+   | **GCN-V**          | 93.02 ± 0.81 | 94.30 ± 0.15 | 96.09 ± 0.17 | 95.73 ± 0.07 |
+   | **GIN**          | 93.26 ± 0.23 | 94.17 ± 0.19 | 96.34 ± 0.15 | 95.95 ± 0.13 |
+   | **GIN-V**           | 92.77 ± 0.66 | 94.54 ± 0.12 | 96.64 ± 0.10 | 96.36 ± 0.10 |
+
+
+
+
+## References
+
+* [1] Hu et al. [Open Graph Benchmark: Datasets for Machine Learning on Graphs](https://arxiv.org/pdf/2005.00687.pdf), NeurIPS 2020.
+* [2] Kipf and Welling. [Semi-Supervised Classification with Graph Convolutional Networks](https://arxiv.org/pdf/1609.02907.pdf), ICLR 2017.
+* [3] Xu et al. [How Powerful are Graph Neural Networks?](https://arxiv.org/pdf/1810.00826.pdf), ICLR 2019.
+* [4] Gilmer et al. [Neural Message Passing for Quantum Chemistry](https://arxiv.org/pdf/1704.01212.pdf), ICML 2017.
+
+Please leave an issue if you have any trouble running the code.
+
+
+Author: Veronika Thost

model-experiments/gnn-based-experiments/data/C++1000/raw/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

model-experiments/gnn-based-experiments/data/C++1000/split/random/test.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:863176076af9965e4d21a8a5d0238e30b612572ccff7202d00d16815b1a7b168
+size 313900

model-experiments/gnn-based-experiments/data/C++1000/split/random/train.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49ad6a1e10d22f6ee4f15eac7dc0cd701dbcc34db44ca4332e4edd7597bdf97e
+size 939493

model-experiments/gnn-based-experiments/data/C++1000/split/random/valid.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84c82c098be4d33d7e2ac03745e1f6fc68b43f6cef9918efbdcbfe0dfc7cd985
+size 314030

model-experiments/gnn-based-experiments/data/C++1400/raw/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

model-experiments/gnn-based-experiments/data/C++1400/split/random/test.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2b259af0f5014ea51b8cf6678be764f36b78f13c507f4e6f2dff2eb01b98f86
+size 260835

model-experiments/gnn-based-experiments/data/C++1400/split/random/train.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37e214f1336702b9768c3df8129109b69d0cd9dd5da4dd166fd6ad2390828954
+size 780550

model-experiments/gnn-based-experiments/data/C++1400/split/random/valid.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9a9295eda0bd543d4b4c498c0f47670f204bc1879a9cdf5a0a5d18ebeb63494
+size 260977

model-experiments/gnn-based-experiments/data/Java250/raw/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

model-experiments/gnn-based-experiments/data/Java250/split/random/test.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd1cd2684506c26c9827876b8713c02d70690f0431ab4af8217e1f08930c35fa
+size 41281

model-experiments/gnn-based-experiments/data/Java250/split/random/train.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8edb0cab6b6a4c8c87caebb650d9ec0731632219c894317406f8d8a35c7b2e2e
+size 121386

model-experiments/gnn-based-experiments/data/Java250/split/random/valid.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b89573f326eeb4fb6db777c011434fbf96f730bfd8ae052ae5860f4610c539d9
+size 41340

model-experiments/gnn-based-experiments/data/Python800/raw/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

model-experiments/gnn-based-experiments/data/Python800/split/random/test.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85f1c4f7ef842002c5205f9a10aee6a843c20817d7415a7b177ab3c5c9016c98
+size 144048

model-experiments/gnn-based-experiments/data/Python800/split/random/train.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfcaa84252f80a28d19b7cfdd22c8454f3410ca1139c4ceb0b4b7ab89b21bf4f
+size 430015

model-experiments/gnn-based-experiments/data/Python800/split/random/valid.csv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47f3e35b3d236f2a6b6ed501b85a350abdd564b8c0f80edd276417504101c0b8
+size 144076