Improve vgg code. Going to add pytorch tensor file loading.

Author: Iainmon

CMakeLists.txt

@@ -270,6 +270,7 @@ set(CHAI_LINKER_ARGS
 add_executable(vgg 
     "${PROJECT_ROOT_DIR}/examples/vgg/test.chpl"
     ${PROJECT_ROOT_DIR}/examples/vgg/VGG.chpl
+    ${CHAI_LIB_FILES}
 )
 add_dependencies(vgg bridge)
 add_dependencies(vgg ChAI)

examples/vgg/test.chpl

@@ -22,10 +22,10 @@ proc getLabels(): [] {
   return lines;
 }
 
-proc confidence(x: []): [] {
+proc confidence(x: ndarray(1,real(32))): [] {
   use Math;
-  var expSum = + reduce exp(x);
-  return (exp(x) / expSum) * 100.0;
+  var expSum = + reduce exp(x.data);
+  return (exp(x.data) / expSum) * 100.0;
 }
 
 // returns (top k indicies, top k condiences)
@@ -41,16 +41,16 @@ proc run(model: shared VGG16(real(32)), file: string) {
     writeln("Converted image to dynamicTensor (or Tensor).");
 
     writeln("Running model on image.");
-    var output: dynamicTensor(real(32)) = model(image);
+    const output: dynamicTensor(real(32)) = model(image);
     writeln("Output shape: ", output.shape());
     writeln("Output type: ", output.type:string);
 
-    const top = output.topk(k);
-    var topArr = top.forceRank(1).array.data;
-    var percent = confidence(output.forceRank(1).array.data);
-
-    var percentTopk = [i in 0..<k] percent(topArr[i]);
-    return (topArr, percentTopk);
+    const predictions: ndarray(1,real(32)) = output.forceRank(rank=1).array;
+    const percent = confidence(predictions);
+    
+    const topPredictions: ndarray(1,int) = predictions.topk(k);
+    var percentTopk = [i in 0..<k] percent[topPredictions[i]];
+    return (topPredictions.data, percentTopk);
 }
 
 proc main(args: [] string) {

lib/DynamicTensor.chpl

@@ -126,13 +126,22 @@ record dynamicTensor : serializable {
         return this;
     }
 
-    proc array(param rank: int) ref : ndarray(rank,eltType) do
+    inline proc ref rankedArray(param rank: int) ref : ndarray(rank,eltType) do
         return (this.meta.borrow() : borrowed BaseTensorResource(eltType, rank)).array;
 
-    proc grad(param rank: int) ref : ndarray(rank,eltType) do
+    inline proc rankedArray(param rank: int): ndarray(rank,eltType) do
+        return (this.meta.borrow() : borrowed BaseTensorResource(eltType, rank)).array;
+
+    inline proc ref rankedGradArray(param rank: int) ref : ndarray(rank,eltType) do
+        return (this.meta.borrow() : borrowed BaseTensorResource(eltType, rank)).grad;
+
+    inline proc rankedGradArray(param rank: int): ndarray(rank,eltType) do
         return (this.meta.borrow() : borrowed BaseTensorResource(eltType, rank)).grad;
 
-    proc data(param rank: int) ref : [] eltType do
+    inline proc ref rankedData(param rank: int) ref : [] eltType do
+        return (this.meta.borrow() : borrowed BaseTensorResource(eltType, rank)).data;
+
+    inline proc rankedData(param rank: int): [] eltType do
         return (this.meta.borrow() : borrowed BaseTensorResource(eltType, rank)).data;
 
 
@@ -156,14 +165,23 @@ record dynamicTensor : serializable {
     }
 }
 
-operator :(in t: dynamicTensor(?eltType), type toType): dynamicTensor(toType) {
+operator :(in t: dynamicTensor(?eltType), type toType): dynamicTensor(toType)
+        where isNumericType(toType) {
     if eltType == toType then return t;
     for param rank in 1..maxRank do
         if t.checkRank(rank) then
             return (t.forceRank(rank) : toType).eraseRank();
     halt("Could not identify rank for this: ", t);
 }
 
+operator :(in t: dynamicTensor(?eltType), type toType: ndarray(?rank,?toEltType)): ndarray(rank,toEltType)
+        where isNumericType(eltType) && isNumericType(toEltType) {
+    if eltType == toEltType then 
+        return t.toNDArray(rank);
+    else
+        return t.toNDArray(rank) : toEltType;
+}
+
 proc type dynamicTensor.detachMode() param : bool {
     return defaultDetachedMode;
 }

lib/NDArray.chpl

@@ -260,7 +260,11 @@ record ndarray : serializable {
 }
 
 
-proc ref ndarray.this(args: int...rank) ref {
+// proc ref ndarray.this(args: int...rank) ref {
+//     return data.this((...args));
+// }
+
+proc ndarray.this(args: int...rank) {
     return data.this((...args));
 }
 
@@ -750,7 +754,7 @@ proc ndarray.topk(k: int): ndarray(1, int) where rank == 1 {
     const mySize = myDom.size;
     if k > mySize then util.err("Cannot get top ", k, " from ", mySize, " elements.");
     var topK: [0..<k] int = 0..<k;
-    var topKData: [0..<k] eltType = myData(0..<k);
+    var topKData: [0..<k] eltType = myData[0..<k];
 
     // Repeatedly find the minimum from the elements of topKData,
     // and then swap it out with some element from the remaining portion
@@ -2304,8 +2308,9 @@ proc ref ndarray.read(fr: IO.fileReader(?)) throws {
         s[i] = fr.read(int);
     var d = util.domainFromShape((...s));
     this._domain = d;
-    for i in d do
-        this.data[i] = fr.read(eltType);
+    // for i in d do
+    //     this.data[i] = fr.read(eltType);
+    fr.read(this.data);
 }
 
 

lib/StaticTensor.chpl

@@ -88,12 +88,19 @@ record staticTensor : serializable {
     }
 }
 
-operator :(in t: staticTensor(?rank,?eltType), type toType): staticTensor(rank,toType) {
+operator :(in t: staticTensor(?rank,?eltType), type toType): staticTensor(rank,toType)
+        where isNumericType(toType) {
     if toType == t.eltType then
         return t;
-    const a = t.array;
-    const b = a : toType;
-    return new staticTensor(b);
+
+    const device = t.device;
+    var newDataResource = new shared Remote(ndarray(rank,eltType),device);
+    ref dat = newDataResource.ptr;
+    on device do
+        dat = t.array : toType;
+    var newTR = new shared TensorResource(newDataResource);
+
+    return new staticTensor(newTR);
 }
 
 proc staticTensor.shapeArray(): [] int {