optimize the time complexity of Imdb dataset loader

lingbai-kong · lingbai-kong · commit f57a6fe6ed00 · 2023-09-09T18:32:24.000+08:00
diff --git a/src/TensorFlowNET.Keras/Datasets/Imdb.cs b/src/TensorFlowNET.Keras/Datasets/Imdb.cs
@@ -94,8 +94,6 @@ public DatasetPass load_data(
             var fileBytes = File.ReadAllBytes(path);
             var (x_train, x_test) = LoadX(fileBytes);
             var (labels_train, labels_test) = LoadY(fileBytes);
-            x_test.astype(np.int32);
-            labels_test.astype(np.int32);
 
             var indices = np.arange<int>(len(x_train));
             np.random.shuffle(indices, seed);
@@ -107,100 +105,113 @@ public DatasetPass load_data(
             x_test = x_test[indices];
             labels_test = labels_test[indices];
 
+            var x_train_array = (int[,])x_train.ToMultiDimArray<int>();
+            var x_test_array = (int[,])x_test.ToMultiDimArray<int>();
+            var labels_train_array = (long[])labels_train.ToArray<long>();
+            var labels_test_array = (long[])labels_test.ToArray<long>();
+
             if (start_char != null)
             {
-                int[,] new_x_train = new int[x_train.shape[0], x_train.shape[1] + 1];
-                for (var i = 0; i < x_train.shape[0]; i++)
+                int[,] new_x_train_array = new int[x_train_array.GetLength(0), x_train_array.GetLength(1) + 1];
+                for (var i = 0; i < x_train_array.GetLength(0); i++)
                 {
-                    new_x_train[i, 0] = (int)start_char;
-                    for (var j = 0; j < x_train.shape[1]; j++)
+                    new_x_train_array[i, 0] = (int)start_char;
+                    for (var j = 0; j < x_train_array.GetLength(1); j++)
                     {
-                        new_x_train[i, j + 1] = x_train[i][j];
+                        if (x_train_array[i, j] == 0)
+                            break;
+                        new_x_train_array[i, j + 1] = x_train_array[i, j];
                     }
                 }
-                int[,] new_x_test = new int[x_test.shape[0], x_test.shape[1] + 1];
-                for (var i = 0; i < x_test.shape[0]; i++)
+                int[,] new_x_test_array = new int[x_test_array.GetLength(0), x_test_array.GetLength(1) + 1];
+                for (var i = 0; i < x_test_array.GetLength(0); i++)
                 {
-                    new_x_test[i, 0] = (int)start_char;
-                    for (var j = 0; j < x_test.shape[1]; j++)
+                    new_x_test_array[i, 0] = (int)start_char;
+                    for (var j = 0; j < x_test_array.GetLength(1); j++)
                     {
-                        new_x_test[i, j + 1] = x_test[i][j];
+                        if (x_test_array[i, j] == 0)
+                            break;
+                        new_x_test_array[i, j + 1] = x_test_array[i, j];
                     }
                 }
-                x_train = new NDArray(new_x_train);
-                x_test = new NDArray(new_x_test);
+                x_train_array = new_x_train_array;
+                x_test_array = new_x_test_array;
             }
             else if (index_from != 0)
             {
-                for (var i = 0; i < x_train.shape[0]; i++)
+                for (var i = 0; i < x_train_array.GetLength(0); i++)
                 {
-                    for (var j = 0; j < x_train.shape[1]; j++)
+                    for (var j = 0; j < x_train_array.GetLength(1); j++)
                     {
-                        if (x_train[i, j] != 0)
-                            x_train[i, j] += index_from;
+                        if (x_train_array[i, j] == 0)
+                            break;
+                        x_train_array[i, j] += index_from;
                     }
                 }
-                for (var i = 0; i < x_test.shape[0]; i++)
+                for (var i = 0; i < x_test_array.GetLength(0); i++)
                 {
-                    for (var j = 0; j < x_test.shape[1]; j++)
+                    for (var j = 0; j < x_test_array.GetLength(1); j++)
                     {
-                        if (x_test[i, j] != 0)
-                            x_test[i, j] += index_from;
+                        if (x_test_array[i, j] == 0)
+                            break;
+                        x_test[i, j] += index_from;
                     }
                 }
             }
 
-            if (maxlen != null)
+            if (maxlen == null)
             {
-                (x_train, labels_train) = data_utils._remove_long_seq((int)maxlen, x_train, labels_train);
-                (x_test, labels_test) = data_utils._remove_long_seq((int)maxlen, x_test, labels_test);
-                if (x_train.size == 0 || x_test.size == 0)
-                    throw new ValueError("After filtering for sequences shorter than maxlen=" +
-                        $"{maxlen}, no sequence was kept. Increase maxlen.");
+                maxlen = max(x_train_array.GetLength(1), x_test_array.GetLength(1));
             }
+            (x_train, labels_train) = data_utils._remove_long_seq((int)maxlen, x_train_array, labels_train_array);
+            (x_test, labels_test) = data_utils._remove_long_seq((int)maxlen, x_test_array, labels_test_array);
+            if (x_train.size == 0 || x_test.size == 0)
+                throw new ValueError("After filtering for sequences shorter than maxlen=" +
+                    $"{maxlen}, no sequence was kept. Increase maxlen.");
 
             var xs = np.concatenate(new[] { x_train, x_test });
             var labels = np.concatenate(new[] { labels_train, labels_test });
+            var xs_array = (int[,])xs.ToMultiDimArray<int>();
 
-            if(num_words == null)
+            if (num_words == null)
             {
                 num_words = 0;
-                for (var i = 0; i < xs.shape[0]; i++)
-                    for (var j = 0; j < xs.shape[1]; j++)
-                        num_words = max((int)num_words, (int)xs[i][j]);
+                for (var i = 0; i < xs_array.GetLength(0); i++)
+                    for (var j = 0; j < xs_array.GetLength(1); j++)
+                        num_words = max((int)num_words, (int)xs_array[i, j]);
             }
 
             // by convention, use 2 as OOV word
             // reserve 'index_from' (=3 by default) characters:
             // 0 (padding), 1 (start), 2 (OOV)
             if (oov_char != null)
             {
-                int[,] new_xs = new int[xs.shape[0], xs.shape[1]];
-                for(var i = 0; i < xs.shape[0]; i++)
+                int[,] new_xs_array = new int[xs_array.GetLength(0), xs_array.GetLength(1)];
+                for (var i = 0; i < xs_array.GetLength(0); i++)
                 {
-                    for(var j = 0; j < xs.shape[1]; j++)
+                    for (var j = 0; j < xs_array.GetLength(1); j++)
                     {
-                        if ((int)xs[i][j] == 0 || skip_top <= (int)xs[i][j] && (int)xs[i][j] < num_words)
-                            new_xs[i, j] = (int)xs[i][j];
+                        if (xs_array[i, j] == 0 || skip_top <= xs_array[i, j] && xs_array[i, j] < num_words)
+                            new_xs_array[i, j] = xs_array[i, j];
                         else
-                            new_xs[i, j] = (int)oov_char;
+                            new_xs_array[i, j] = (int)oov_char;
                     }
                 }
-                xs = new NDArray(new_xs);
+                xs = new NDArray(new_xs_array);
             }
             else
             {
-                int[,] new_xs = new int[xs.shape[0], xs.shape[1]];
-                for (var i = 0; i < xs.shape[0]; i++)
+                int[,] new_xs_array = new int[xs_array.GetLength(0), xs_array.GetLength(1)];
+                for (var i = 0; i < xs_array.GetLength(0); i++)
                 {
                     int k = 0;
-                    for (var j = 0; j < xs.shape[1]; j++)
+                    for (var j = 0; j < xs_array.GetLength(1); j++)
                     {
-                        if ((int)xs[i][j] == 0 || skip_top <= (int)xs[i][j] && (int)xs[i][j] < num_words)
-                            new_xs[i, k++] = (int)xs[i][j];
+                        if (xs_array[i, j] == 0 || skip_top <= xs_array[i, j] && xs_array[i, j] < num_words)
+                            new_xs_array[i, k++] = xs_array[i, j];
                     }
                 }
-                xs = new NDArray(new_xs);
+                xs = new NDArray(new_xs_array);
             }
 
             var idx = len(x_train);
diff --git a/src/TensorFlowNET.Keras/Utils/data_utils.cs b/src/TensorFlowNET.Keras/Utils/data_utils.cs
@@ -54,23 +54,25 @@ public static (NDArray, NDArray) _remove_long_seq(int maxlen, NDArray seq, NDArr
 
             */
             List<int[]> new_seq = new List<int[]>();
-            List<int> new_label = new List<int>();
+            List<long> new_label = new List<long>();
 
-            for (var i = 0; i < seq.shape[0]; i++)
+            var seq_array = (int[,])seq.ToMultiDimArray<int>();
+            var label_array = (long[])label.ToArray<long>();
+            for (var i = 0; i < seq_array.GetLength(0); i++)
             {
-                if (maxlen < seq.shape[1] && seq[i][maxlen] != 0)
+                if (maxlen < seq_array.GetLength(1) && seq_array[i,maxlen] != 0)
                     continue;
                 int[] sentence = new int[maxlen];
-                for (var j = 0; j < maxlen && j < seq.shape[1]; j++)
+                for (var j = 0; j < maxlen && j < seq_array.GetLength(1); j++)
                 {
-                    sentence[j] = seq[i, j];
+                    sentence[j] = seq_array[i, j];
                 }
                 new_seq.Add(sentence);
-                new_label.Add(label[i]);
+                new_label.Add(label_array[i]);
             }
 
             int[,] new_seq_array = new int[new_seq.Count, maxlen];
-            int[] new_label_array = new int[new_label.Count];
+            long[] new_label_array = new long[new_label.Count];
 
             for (var i = 0; i < new_seq.Count; i++)
             {
diff --git a/test/TensorFlowNET.UnitTest/Dataset/DatasetTest.cs b/test/TensorFlowNET.UnitTest/Dataset/DatasetTest.cs
@@ -204,7 +204,7 @@ public void GetData()
         {
             var vocab_size = 20000; // Only consider the top 20k words
             var maxlen = 200; // Only consider the first 200 words of each movie review
-            var dataset = keras.datasets.imdb.load_data(num_words: vocab_size);
+            var dataset = keras.datasets.imdb.load_data(num_words: vocab_size, maxlen: maxlen);
             var x_train = dataset.Train.Item1;
             var y_train = dataset.Train.Item2;
             var x_val = dataset.Test.Item1;
@@ -217,16 +217,17 @@ public void GetData()
         }
         IEnumerable<int[]> RemoveZeros(NDArray data)
         {
+            var data_array = (int[,])data.ToMultiDimArray<int>();
             List<int[]> new_data = new List<int[]>();
-            for (var i = 0; i < data.shape[0]; i++)
+            for (var i = 0; i < data_array.GetLength(0); i++)
             {
                 List<int> new_array = new List<int>();
-                for (var j = 0; j < data.shape[1]; j++)
+                for (var j = 0; j < data_array.GetLength(1); j++)
                 {
-                    if (data[i][j] == 0)
+                    if (data_array[i, j] == 0)
                         break;
                     else
-                        new_array.Add((int)data[i][j]);
+                        new_array.Add(data_array[i, j]);
                 }
                 new_data.Add(new_array.ToArray());
             }

Original file line number	Diff line number	Diff line change
`@@ -94,8 +94,6 @@ public DatasetPass load_data(`
`94`	`94`	`var fileBytes = File.ReadAllBytes(path);`
`95`	`95`	`var (x_train, x_test) = LoadX(fileBytes);`
`96`	`96`	`var (labels_train, labels_test) = LoadY(fileBytes);`
`97`		`- x_test.astype(np.int32);`
`98`		`- labels_test.astype(np.int32);`
`99`	`97`
`100`	`98`	`var indices = np.arange<int>(len(x_train));`
`101`	`99`	`np.random.shuffle(indices, seed);`
`@@ -107,100 +105,113 @@ public DatasetPass load_data(`
`107`	`105`	`x_test = x_test[indices];`
`108`	`106`	`labels_test = labels_test[indices];`
`109`	`107`
	`108`	`+ var x_train_array = (int[,])x_train.ToMultiDimArray<int>();`
	`109`	`+ var x_test_array = (int[,])x_test.ToMultiDimArray<int>();`
	`110`	`+ var labels_train_array = (long[])labels_train.ToArray<long>();`
	`111`	`+ var labels_test_array = (long[])labels_test.ToArray<long>();`
	`112`	`+`
`110`	`113`	`if (start_char != null)`
`111`	`114`	`{`
`112`		`- int[,] new_x_train = new int[x_train.shape[0], x_train.shape[1] + 1];`
`113`		`- for (var i = 0; i < x_train.shape[0]; i++)`
	`115`	`+ int[,] new_x_train_array = new int[x_train_array.GetLength(0), x_train_array.GetLength(1) + 1];`
	`116`	`+ for (var i = 0; i < x_train_array.GetLength(0); i++)`
`114`	`117`	`{`
`115`		`- new_x_train[i, 0] = (int)start_char;`
`116`		`- for (var j = 0; j < x_train.shape[1]; j++)`
	`118`	`+ new_x_train_array[i, 0] = (int)start_char;`
	`119`	`+ for (var j = 0; j < x_train_array.GetLength(1); j++)`
`117`	`120`	`{`
`118`		`- new_x_train[i, j + 1] = x_train[i][j];`
	`121`	`+ if (x_train_array[i, j] == 0)`
	`122`	`+ break;`
	`123`	`+ new_x_train_array[i, j + 1] = x_train_array[i, j];`
`119`	`124`	`}`
`120`	`125`	`}`
`121`		`- int[,] new_x_test = new int[x_test.shape[0], x_test.shape[1] + 1];`
`122`		`- for (var i = 0; i < x_test.shape[0]; i++)`
	`126`	`+ int[,] new_x_test_array = new int[x_test_array.GetLength(0), x_test_array.GetLength(1) + 1];`
	`127`	`+ for (var i = 0; i < x_test_array.GetLength(0); i++)`
`123`	`128`	`{`
`124`		`- new_x_test[i, 0] = (int)start_char;`
`125`		`- for (var j = 0; j < x_test.shape[1]; j++)`
	`129`	`+ new_x_test_array[i, 0] = (int)start_char;`
	`130`	`+ for (var j = 0; j < x_test_array.GetLength(1); j++)`
`126`	`131`	`{`
`127`		`- new_x_test[i, j + 1] = x_test[i][j];`
	`132`	`+ if (x_test_array[i, j] == 0)`
	`133`	`+ break;`
	`134`	`+ new_x_test_array[i, j + 1] = x_test_array[i, j];`
`128`	`135`	`}`
`129`	`136`	`}`
`130`		`- x_train = new NDArray(new_x_train);`
`131`		`- x_test = new NDArray(new_x_test);`
	`137`	`+ x_train_array = new_x_train_array;`
	`138`	`+ x_test_array = new_x_test_array;`
`132`	`139`	`}`
`133`	`140`	`else if (index_from != 0)`
`134`	`141`	`{`
`135`		`- for (var i = 0; i < x_train.shape[0]; i++)`
	`142`	`+ for (var i = 0; i < x_train_array.GetLength(0); i++)`
`136`	`143`	`{`
`137`		`- for (var j = 0; j < x_train.shape[1]; j++)`
	`144`	`+ for (var j = 0; j < x_train_array.GetLength(1); j++)`
`138`	`145`	`{`
`139`		`- if (x_train[i, j] != 0)`
`140`		`- x_train[i, j] += index_from;`
	`146`	`+ if (x_train_array[i, j] == 0)`
	`147`	`+ break;`
	`148`	`+ x_train_array[i, j] += index_from;`
`141`	`149`	`}`
`142`	`150`	`}`
`143`		`- for (var i = 0; i < x_test.shape[0]; i++)`
	`151`	`+ for (var i = 0; i < x_test_array.GetLength(0); i++)`
`144`	`152`	`{`
`145`		`- for (var j = 0; j < x_test.shape[1]; j++)`
	`153`	`+ for (var j = 0; j < x_test_array.GetLength(1); j++)`
`146`	`154`	`{`
`147`		`- if (x_test[i, j] != 0)`
`148`		`- x_test[i, j] += index_from;`
	`155`	`+ if (x_test_array[i, j] == 0)`
	`156`	`+ break;`
	`157`	`+ x_test[i, j] += index_from;`
`149`	`158`	`}`
`150`	`159`	`}`
`151`	`160`	`}`
`152`	`161`
`153`		`- if (maxlen != null)`
	`162`	`+ if (maxlen == null)`
`154`	`163`	`{`
`155`		`- (x_train, labels_train) = data_utils._remove_long_seq((int)maxlen, x_train, labels_train);`
`156`		`- (x_test, labels_test) = data_utils._remove_long_seq((int)maxlen, x_test, labels_test);`
`157`		`- if (x_train.size == 0 \|\| x_test.size == 0)`
`158`		`- throw new ValueError("After filtering for sequences shorter than maxlen=" +`
`159`		`- $"{maxlen}, no sequence was kept. Increase maxlen.");`
	`164`	`+ maxlen = max(x_train_array.GetLength(1), x_test_array.GetLength(1));`
`160`	`165`	`}`
	`166`	`+ (x_train, labels_train) = data_utils._remove_long_seq((int)maxlen, x_train_array, labels_train_array);`
	`167`	`+ (x_test, labels_test) = data_utils._remove_long_seq((int)maxlen, x_test_array, labels_test_array);`
	`168`	`+ if (x_train.size == 0 \|\| x_test.size == 0)`
	`169`	`+ throw new ValueError("After filtering for sequences shorter than maxlen=" +`
	`170`	`+ $"{maxlen}, no sequence was kept. Increase maxlen.");`
`161`	`171`
`162`	`172`	`var xs = np.concatenate(new[] { x_train, x_test });`
`163`	`173`	`var labels = np.concatenate(new[] { labels_train, labels_test });`
	`174`	`+ var xs_array = (int[,])xs.ToMultiDimArray<int>();`
`164`	`175`
`165`		`- if(num_words == null)`
	`176`	`+ if (num_words == null)`
`166`	`177`	`{`
`167`	`178`	`num_words = 0;`
`168`		`- for (var i = 0; i < xs.shape[0]; i++)`
`169`		`- for (var j = 0; j < xs.shape[1]; j++)`
`170`		`- num_words = max((int)num_words, (int)xs[i][j]);`
	`179`	`+ for (var i = 0; i < xs_array.GetLength(0); i++)`
	`180`	`+ for (var j = 0; j < xs_array.GetLength(1); j++)`
	`181`	`+ num_words = max((int)num_words, (int)xs_array[i, j]);`
`171`	`182`	`}`
`172`	`183`
`173`	`184`	`// by convention, use 2 as OOV word`
`174`	`185`	`// reserve 'index_from' (=3 by default) characters:`
`175`	`186`	`// 0 (padding), 1 (start), 2 (OOV)`
`176`	`187`	`if (oov_char != null)`
`177`	`188`	`{`
`178`		`- int[,] new_xs = new int[xs.shape[0], xs.shape[1]];`
`179`		`- for(var i = 0; i < xs.shape[0]; i++)`
	`189`	`+ int[,] new_xs_array = new int[xs_array.GetLength(0), xs_array.GetLength(1)];`
	`190`	`+ for (var i = 0; i < xs_array.GetLength(0); i++)`
`180`	`191`	`{`
`181`		`- for(var j = 0; j < xs.shape[1]; j++)`
	`192`	`+ for (var j = 0; j < xs_array.GetLength(1); j++)`
`182`	`193`	`{`
`183`		`- if ((int)xs[i][j] == 0 \|\| skip_top <= (int)xs[i][j] && (int)xs[i][j] < num_words)`
`184`		`- new_xs[i, j] = (int)xs[i][j];`
	`194`	`+ if (xs_array[i, j] == 0 \|\| skip_top <= xs_array[i, j] && xs_array[i, j] < num_words)`
	`195`	`+ new_xs_array[i, j] = xs_array[i, j];`
`185`	`196`	`else`
`186`		`- new_xs[i, j] = (int)oov_char;`
	`197`	`+ new_xs_array[i, j] = (int)oov_char;`
`187`	`198`	`}`
`188`	`199`	`}`
`189`		`- xs = new NDArray(new_xs);`
	`200`	`+ xs = new NDArray(new_xs_array);`
`190`	`201`	`}`
`191`	`202`	`else`
`192`	`203`	`{`
`193`		`- int[,] new_xs = new int[xs.shape[0], xs.shape[1]];`
`194`		`- for (var i = 0; i < xs.shape[0]; i++)`
	`204`	`+ int[,] new_xs_array = new int[xs_array.GetLength(0), xs_array.GetLength(1)];`
	`205`	`+ for (var i = 0; i < xs_array.GetLength(0); i++)`
`195`	`206`	`{`
`196`	`207`	`int k = 0;`
`197`		`- for (var j = 0; j < xs.shape[1]; j++)`
	`208`	`+ for (var j = 0; j < xs_array.GetLength(1); j++)`
`198`	`209`	`{`
`199`		`- if ((int)xs[i][j] == 0 \|\| skip_top <= (int)xs[i][j] && (int)xs[i][j] < num_words)`
`200`		`- new_xs[i, k++] = (int)xs[i][j];`
	`210`	`+ if (xs_array[i, j] == 0 \|\| skip_top <= xs_array[i, j] && xs_array[i, j] < num_words)`
	`211`	`+ new_xs_array[i, k++] = xs_array[i, j];`
`201`	`212`	`}`
`202`	`213`	`}`
`203`		`- xs = new NDArray(new_xs);`
	`214`	`+ xs = new NDArray(new_xs_array);`
`204`	`215`	`}`
`205`	`216`
`206`	`217`	`var idx = len(x_train);`
Original file line number	Diff line number	Diff line change
`@@ -54,23 +54,25 @@ public static (NDArray, NDArray) _remove_long_seq(int maxlen, NDArray seq, NDArr`
`54`	`54`
`55`	`55`	`*/`
`56`	`56`	`List<int[]> new_seq = new List<int[]>();`
`57`		`- List<int> new_label = new List<int>();`
	`57`	`+ List<long> new_label = new List<long>();`
`58`	`58`
`59`		`- for (var i = 0; i < seq.shape[0]; i++)`
	`59`	`+ var seq_array = (int[,])seq.ToMultiDimArray<int>();`
	`60`	`+ var label_array = (long[])label.ToArray<long>();`
	`61`	`+ for (var i = 0; i < seq_array.GetLength(0); i++)`
`60`	`62`	`{`
`61`		`- if (maxlen < seq.shape[1] && seq[i][maxlen] != 0)`
	`63`	`+ if (maxlen < seq_array.GetLength(1) && seq_array[i,maxlen] != 0)`
`62`	`64`	`continue;`
`63`	`65`	`int[] sentence = new int[maxlen];`
`64`		`- for (var j = 0; j < maxlen && j < seq.shape[1]; j++)`
	`66`	`+ for (var j = 0; j < maxlen && j < seq_array.GetLength(1); j++)`
`65`	`67`	`{`
`66`		`- sentence[j] = seq[i, j];`
	`68`	`+ sentence[j] = seq_array[i, j];`
`67`	`69`	`}`
`68`	`70`	`new_seq.Add(sentence);`
`69`		`- new_label.Add(label[i]);`
	`71`	`+ new_label.Add(label_array[i]);`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`int[,] new_seq_array = new int[new_seq.Count, maxlen];`
`73`		`- int[] new_label_array = new int[new_label.Count];`
	`75`	`+ long[] new_label_array = new long[new_label.Count];`
`74`	`76`
`75`	`77`	`for (var i = 0; i < new_seq.Count; i++)`
`76`	`78`	`{`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ public void GetData()`
`204`	`204`	`{`
`205`	`205`	`var vocab_size = 20000; // Only consider the top 20k words`
`206`	`206`	`var maxlen = 200; // Only consider the first 200 words of each movie review`
`207`		`- var dataset = keras.datasets.imdb.load_data(num_words: vocab_size);`
	`207`	`+ var dataset = keras.datasets.imdb.load_data(num_words: vocab_size, maxlen: maxlen);`
`208`	`208`	`var x_train = dataset.Train.Item1;`
`209`	`209`	`var y_train = dataset.Train.Item2;`
`210`	`210`	`var x_val = dataset.Test.Item1;`
`@@ -217,16 +217,17 @@ public void GetData()`
`217`	`217`	`}`
`218`	`218`	`IEnumerable<int[]> RemoveZeros(NDArray data)`
`219`	`219`	`{`
	`220`	`+ var data_array = (int[,])data.ToMultiDimArray<int>();`
`220`	`221`	`List<int[]> new_data = new List<int[]>();`
`221`		`- for (var i = 0; i < data.shape[0]; i++)`
	`222`	`+ for (var i = 0; i < data_array.GetLength(0); i++)`
`222`	`223`	`{`
`223`	`224`	`List<int> new_array = new List<int>();`
`224`		`- for (var j = 0; j < data.shape[1]; j++)`
	`225`	`+ for (var j = 0; j < data_array.GetLength(1); j++)`
`225`	`226`	`{`
`226`		`- if (data[i][j] == 0)`
	`227`	`+ if (data_array[i, j] == 0)`
`227`	`228`	`break;`
`228`	`229`	`else`
`229`		`- new_array.Add((int)data[i][j]);`
	`230`	`+ new_array.Add(data_array[i, j]);`
`230`	`231`	`}`
`231`	`232`	`new_data.Add(new_array.ToArray());`
`232`	`233`	`}`