First Commit

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

.idea/Transport_Mode_Detector.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.9 (pytorchbook) (2)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (pytorchbook) (2)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Transport_Mode_Detector.iml" filepath="$PROJECT_DIR$/.idea/Transport_Mode_Detector.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

app.py

@@ -0,0 +1,74 @@
+import gradio as gr
+import numpy as np
+import torch
+from modality_lstm import ModalityLSTM
+import torch.nn as nn
+from helper import score_to_modality
+from PIL import Image
+
+label_mapping = {
+        'car': [0,'images/Cars.jpg'],
+        'walk': [1,'images/walk.jpg'],
+        'bus': [2,'images/bus.jpg'],
+        'train': [3,'images/train.jpg'],
+        'subway': [4,'images/subway.jpg'],
+        'bike': [5,'images/bike.jpg'],
+        'run': [6,'images/walk.jpg'],
+        'boat': [7,'images/walk.jpg'],
+        'airplane': [8,'images/walk.jpg'],
+        'motorcycle': [9,'images/walk.jpg'],
+        'taxi': [10,'images/taxi.jpg']
+    }
+
+def pred(dist,speed,accel,timedelta,jerk,bearing,bearing_rate):
+
+
+
+    batch_size = 1
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    train_on_gpu = False
+    output_size = 5
+    hidden_dim = 128
+    trip_dim = 7
+    n_layers = 2
+    drop_prob = 0.2
+    net = ModalityLSTM(trip_dim, output_size, batch_size, hidden_dim, n_layers, train_on_gpu, drop_prob, lstm_drop_prob=0.2)
+    net.load_state_dict(torch.load("Model_Wieghts"))
+    net.eval()
+
+    a=torch.tensor([[dist,speed,accel,timedelta,jerk,bearing,bearing_rate]])
+    a=a.float()
+    a=a.unsqueeze(0)
+    l = torch.tensor([1]).long()
+    b,c=net(a,l)
+    b=b.squeeze(0)
+    b=score_to_modality(b)
+    b=b[0]
+    print(b)
+    for k,v in label_mapping.items():
+        if b == v[0]:
+            return (str(k),Image.open(v[1]))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def greet(name):
+  return "Hello " + name + "!!"
+
+iface = gr.Interface(fn=pred, inputs=['number',"number","number",'number',"number","number","number"], outputs=["text",gr.outputs.Image(type="pil")])
+iface.launch()

classifier.py

@@ -0,0 +1,99 @@
+import torch
+import numpy as np
+from torch import nn
+
+from data_loader import DataLoader
+from helper import ValTest
+from modality_lstm import ModalityLSTM
+
+batch_size = 32
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+train_on_gpu = True
+output_size = 5
+hidden_dim = 128
+trip_dim = 7
+n_layers = 2
+drop_prob = 0.2
+net = ModalityLSTM(trip_dim, output_size, batch_size, hidden_dim, n_layers, train_on_gpu, drop_prob, lstm_drop_prob=0.2)
+lr=0.001
+loss_function = nn.CrossEntropyLoss(ignore_index=-1)
+optimizer = torch.optim.Adam(net.parameters(), lr=lr)
+epochs = 6
+print_every = 5
+log_every = 1
+evaluate_every = 100
+
+clip = 0.2 # gradient clipping
+
+if train_on_gpu:
+    net.cuda()
+net.train()
+
+dl = DataLoader(batchsize=batch_size, read_from_pickle=True)
+dl.prepare_data()
+
+def pad_trajs(trajs, lengths):
+    for w, elem in enumerate(trajs):
+        while len(elem) < lengths[0]:
+            elem.append([-1] * trip_dim)
+    return trajs
+
+
+losses, avg_losses = [], []
+
+validator = ValTest(dl.val_batches, net, trip_dim, batch_size, device, loss_function, output_size, dl.get_val_size())
+test = ValTest(dl.test_batches, net, trip_dim, batch_size, device, loss_function, output_size, dl.get_test_size())
+
+for e in range(1,epochs+1):
+    print("epoch ",e)
+    hidden = net.init_hidden()
+    counter = 0
+    torch.cuda.empty_cache()
+    for train_sorted, labels_sorted in dl.batches():
+
+        counter += 1
+        lengths = [len(x) for x in train_sorted]
+        print("Lengths are ", lengths)
+        print("SUm of lengths",sum(lengths))
+        train_sorted = pad_trajs(train_sorted, lengths)
+
+        X = np.asarray(train_sorted, dtype=np.float)
+        input_tensor = torch.from_numpy(X)
+        print("Input tensor is ",input_tensor.shape)
+        input_tensor = input_tensor.to(device)
+
+        net.zero_grad()
+        output, max_padding_for_this_batch = net(input_tensor, lengths)
+        print("Output is",output.shape)
+
+        for labelz in labels_sorted:
+            while len(labelz) < max_padding_for_this_batch:
+                labelz.append(-1)
+
+        labels_for_loss = torch.tensor(labels_sorted).view(max_padding_for_this_batch * batch_size, -1).squeeze(
+            1).long().to(device)
+
+        print("Labels for loss is",len(labels_for_loss))
+
+        loss = loss_function(output.view(
+                            max_padding_for_this_batch*batch_size, -1),
+                            labels_for_loss)
+        loss.backward()
+        nn.utils.clip_grad_norm_(net.parameters(), clip)
+        optimizer.step()
+
+        if counter % log_every == 0:
+            losses.append(loss.item())
+        if counter % print_every == 0:
+            avg_losses.append(sum(losses[-50:]) / 50)
+            print(
+                f'Epoch: {e:2d}. {counter:d} of {int(dl.get_train_size() / batch_size):d} {avg_losses[len(avg_losses) - 1]:f} Loss: {loss.item():.4f}')
+        if counter % evaluate_every == 0:
+            validator.run()
+
+torch.save(net.state_dict(),"Model_Wieghts")
+print("Testing")
+
+test.run()
+
+torch.save(net.state_dict(),"Model_Wieghts")

data_enrich.py

@@ -0,0 +1,175 @@
+import os
+import pickle
+from math import cos, sin, atan2
+
+import numpy as np
+from geopy import distance
+
+class DataEnrich:
+
+    def __init__(self):
+        pass
+
+    def _load_raw_pickle(self):
+        return pickle.load(open("data/raw_labeled.pkl","rb"))
+
+    def consolidate_trajectories(self):
+        raw_dfs = self._load_raw_pickle()
+        trajectories = []
+        for traj_of_person in raw_dfs:
+            dfs_with_label = []
+            for traj in traj_of_person:
+                if "label" in traj.columns:
+                    traj = traj.replace(to_replace='None', value=np.nan).dropna()
+                    traj.reset_index(inplace=True)
+                    dfs_with_label.append(traj)
+            if dfs_with_label:
+                trajectories.extend(dfs_with_label)
+        return trajectories
+
+    def _calc_speed(self, distance, ts_a, ts_b):
+        time_delta = ts_b - ts_a
+        if time_delta.total_seconds() == 0:
+            return 0
+        return distance / time_delta.total_seconds()  # m/s
+
+    def _calc_accel(self, speed_a, speed_b, ts_a, ts_b):
+        time_delta = ts_b - ts_a
+        speed_delta = speed_b - speed_a
+        if time_delta.total_seconds() == 0:
+            return 0
+        return speed_delta / time_delta.total_seconds()  # m/s^2
+
+    def _calc_jerk(self, acc_a, acc_b, ts_a, ts_b):
+        time_delta = ts_b - ts_a
+        acc_delta = acc_b - acc_a
+        if time_delta.total_seconds() == 0:
+            return 0
+        return acc_delta / time_delta.total_seconds()
+
+    def _calc_bearing_rate(self, bearing_a, bearing_b, ts_a, ts_b):
+        time_delta = ts_b - ts_a
+        bear_delta = bearing_b - bearing_a
+        if time_delta.total_seconds() == 0:
+            return 0
+        return bear_delta / time_delta.total_seconds()
+
+    def calc_dist_for_row(self, trajectory_frame, i):
+        lat_1 = trajectory_frame["lat"][i-1]
+        lat_2 = trajectory_frame["lat"][i]
+        if lat_1 > 90:
+            print("Faulty", lat_1)
+            lat_1 /= 10
+        if lat_2 > 90:
+            print("Faulty", lat_2)
+            lat_2 /= 10
+
+        point_a = (lat_1, trajectory_frame["lon"][i-1])
+        point_b = (lat_2, trajectory_frame["lon"][i])
+        if point_a[0] == point_b[0] and point_a[1] == point_b[1]:
+            trajectory_frame["dist"][i] = 0
+        else:
+            trajectory_frame["dist"][i] = distance.distance((point_a[0], point_a[1]), (point_b[0], point_b[1])).m
+
+    def calc_speed_for_row(self, trajectory_frame, i):
+        trajectory_frame["speed"][i] = self._calc_speed(trajectory_frame["dist"][i],
+                                                        trajectory_frame["datetime"][i-1],
+                                                        trajectory_frame["datetime"][i]
+                                                        )
+
+    def calc_accel_for_row(self, trajectory_frame, i):
+        trajectory_frame["accel"][i] = self._calc_accel(trajectory_frame["speed"][i-1],
+                                                        trajectory_frame["speed"][i],
+                                                        trajectory_frame["datetime"][i - 1],
+                                                        trajectory_frame["datetime"][i]
+                                                        )
+
+    def set_sample_rate(self, trajectory_frame, min_sec_distance_between_points):
+        i = 1
+        indices_to_del = []
+        deleted = 1
+        while i < len(trajectory_frame)-deleted:
+            ts1 = trajectory_frame["datetime"][i]
+            ts2 = trajectory_frame["datetime"][i+deleted]
+            delta = ts2-ts1
+            if delta.seconds < min_sec_distance_between_points:
+                deleted+=1
+                indices_to_del.append(i)
+                continue
+            i+=deleted
+            deleted = 1
+        if indices_to_del:
+            trajectory_frame.drop(trajectory_frame.index[indices_to_del],inplace=True)
+            trajectory_frame.reset_index(inplace=True)
+
+    def set_time_between_points(self, trajectory_frame, i):
+        trajectory_frame["timedelta"][i] = (trajectory_frame["datetime"][i]-trajectory_frame["datetime"][i-1]).total_seconds()
+
+    def calc_jerk_for_row(self, trajectory_frame, i):
+        trajectory_frame["jerk"][i] = self._calc_jerk(trajectory_frame["accel"][i - 1],
+                                                        trajectory_frame["accel"][i],
+                                                        trajectory_frame["datetime"][i - 1],
+                                                        trajectory_frame["datetime"][i]
+                                                        )
+
+    def calc_bearing_for_row(self, trajectory_frame, i):
+        a_lat = trajectory_frame["lat"][i - 1]
+        a_lon = trajectory_frame["lon"][i - 1]
+        b_lat = trajectory_frame["lat"][i]
+        b_lon = trajectory_frame["lon"][i]
+        x = cos(b_lat) * sin(b_lon-a_lon)
+        y = cos(a_lat) * sin(b_lat) - sin(a_lat) * cos(b_lat) * cos(b_lon-a_lon)
+        trajectory_frame["bearing"][i] = atan2(x, y)
+
+    def calc_bearing_rate_for_row(self, trajectory_frame, i):
+        trajectory_frame["bearing_rate"][i] = self._calc_bearing_rate(trajectory_frame["bearing"][i - 1],
+                                                        trajectory_frame["bearing"][i],
+                                                        trajectory_frame["datetime"][i - 1],
+                                                        trajectory_frame["datetime"][i]
+                                                        )
+
+    def calc_features_for_frame(self, traj_frame):
+        traj_frame["dist"] = 0
+        traj_frame["timedelta"] = 0
+        traj_frame["speed"] = 0
+        traj_frame["accel"] = 0
+        traj_frame["jerk"] = 0
+        traj_frame["bearing"] = 0
+        traj_frame["bearing_rate"] = 0
+
+        for i, elem in traj_frame.iterrows():
+            if i == 0:
+                continue
+            self.set_time_between_points(traj_frame, i)
+            self.calc_dist_for_row(traj_frame, i)
+            self.calc_speed_for_row(traj_frame, i)
+            self.calc_accel_for_row(traj_frame, i)
+            self.calc_jerk_for_row(traj_frame, i)
+            self.calc_bearing_for_row(traj_frame, i)
+            self.calc_bearing_rate_for_row(traj_frame, i)
+
+    def get_enriched_data(self, from_pickle):
+        if from_pickle:
+            if os.path.isfile("data/raw_enriched.pkl"):
+                print("Reading raw_enriched.pkl")
+                return pickle.load(open("data/raw_enriched.pkl", "rb"))
+            else:
+                print("No pickled enriched dataset, creating. This will take a while.")
+        traj = self.consolidate_trajectories()
+        for elem in traj:
+            self.set_sample_rate(elem, 5)
+            self.calc_features_for_frame(elem)
+        print("Done, dumping")
+        pickle.dump(traj, open("data/raw_enriched.pkl", "wb"))
+
+        return traj
+
+
+if __name__ == '__main__':
+    a=DataEnrich()
+    z=a.get_enriched_data(False)
+    print(z)
+    print("DOneP")
+
+
+

data_loader.py

@@ -0,0 +1,155 @@
+import random
+from operator import itemgetter
+
+from data_enrich import DataEnrich
+
+
+class DataLoader:
+
+    label_mapping = {
+        'car': 0,
+        'walk': 1,
+        'bus': 2,
+        'train': 3,
+        'subway': 4,
+        'bike': 5,
+        'run': 6,
+        'boat': 7,
+        'airplane': 8,
+        'motorcycle': 9,
+        'taxi': 10
+    }
+
+    fields_to_feed = ["dist", "speed", "accel", "timedelta", "jerk", "bearing", "bearing_rate"]
+    labels_to_remove = ["boat", "motorcycle", "airplane", "run", "bike"]
+
+
+    def __init__(self, test_ratio=0.2, val_ratio=0.1, batchsize=4, read_from_pickle=True):
+        de = DataEnrich()
+        self._raw = de.get_enriched_data(read_from_pickle)
+        self._test_ratio = test_ratio
+        self._val_ratio = val_ratio
+        self._batchsize = batchsize
+
+    def _remove_traj_containing_labels(self):
+        cleaned = []
+        for elem in self._raw:
+            if len(elem) == 0:
+                continue
+            if all(x not in list(elem["label"]) for x in self.labels_to_remove):
+                cleaned.append(elem)
+        self._raw = cleaned
+
+    def _merge_labels(self, target_label, label_to_remove):
+        for elem in self._raw:
+            if label_to_remove in list(elem["label"]):
+                elem["label"] = elem["label"].replace(to_replace=label_to_remove, value=target_label)
+
+    def _labels_to_int_repr(self):
+        for elem in self._raw:
+            elem["label"] = elem["label"].apply(lambda x: self.label_mapping[x])
+
+    def _get_split_indices(self, traj):
+        train_size = int((1 - self._test_ratio) * len(traj))
+        val_size = len(traj) - int((1 - self._val_ratio) * len(traj))
+
+        indices = [x for x in range(len(traj))]
+
+        indices_for_training = random.sample(indices, train_size)
+        indices_for_validation = random.sample(indices_for_training, val_size)
+        indices_for_training = set(indices_for_training) - set(indices_for_validation)
+        indices_for_testing = set(indices) - indices_for_training
+        indices_for_testing = list(indices_for_testing)
+
+        return list(indices_for_training), list(indices_for_testing), list(indices_for_validation)
+
+    def _set_splitted_data(self, traj, labels):
+
+        i_train, i_test, i_val = self._get_split_indices(traj)
+
+        random.shuffle(i_train)
+
+        self.test_data = list(itemgetter(*i_test)(traj))
+        self.val_data = list(itemgetter(*i_val)(traj))
+        self.train_data = list(itemgetter(*i_train)(traj))
+        self.test_labels = list(itemgetter(*i_test)(labels))
+        self.val_labels = list(itemgetter(*i_val)(labels))
+        self.train_labels = list(itemgetter(*i_train)(labels))
+
+    def _split_too_long_traj(self, traj, labels, max_points):
+        if len(traj) > max_points*2:
+            splitted_traj, splitted_labels = [],[]
+            num_subsets = len(traj) // max_points
+            print("Splitting trajectory with length ", len(traj), "in ", num_subsets, "trajectories")
+            for i in range(num_subsets):
+                end_pointer = len(traj)-1 if ((i+1)*max_points)+max_points > len(traj) else (i*max_points)+max_points
+                traj_subset = traj[i*max_points:end_pointer]
+                labels_subset = labels[i*max_points:end_pointer]
+                assert len(traj_subset) == len(labels_subset)
+                splitted_traj.append(traj_subset)
+                splitted_labels.append(labels_subset)
+            return splitted_traj, splitted_labels
+        return [traj], [labels]
+
+    def prepare_data(self):
+        trajs = []
+        labels = []
+
+        self._remove_traj_containing_labels()
+        self._merge_labels("car", "taxi")
+        self._labels_to_int_repr()
+
+        for elem in self._raw:
+            assert len(elem) > 0
+            data_ = elem[self.fields_to_feed].values.tolist()
+            label_ = elem["label"].values.tolist()
+            data_, label_ = self._split_too_long_traj(data_, label_, 350)
+            trajs.extend(data_)
+            labels.extend(label_)
+
+        self._set_splitted_data(trajs, labels)
+
+    def batches(self):
+        for i in range(0, len(self.train_data), self._batchsize):
+
+            if len(self.train_data[i:i + self._batchsize]) < self._batchsize:
+                break  # drop last incomplete batch
+
+            labels_sorted = sorted(self.train_labels[i:i + self._batchsize:], key=len, reverse=True)
+            train_sorted = sorted(self.train_data[i:i + self._batchsize:], key=len, reverse=True)
+            for p in range(len(labels_sorted)):
+                    assert len(labels_sorted[p]) == len(train_sorted[p])
+            yield train_sorted, labels_sorted
+
+    def val_batches(self):
+        for i in range(0, len(self.val_data), self._batchsize):
+
+            if len(self.val_data[i:i + self._batchsize]) < self._batchsize:
+                break  # drop last incomplete batch
+
+            labels_sorted = sorted(self.val_labels[i:i + self._batchsize:], key=len, reverse=True)
+            val_sorted = sorted(self.val_data[i:i + self._batchsize:], key=len, reverse=True)
+            for p in range(len(labels_sorted)):
+                    assert len(labels_sorted[p]) == len(val_sorted[p])
+            yield val_sorted, labels_sorted
+
+    def test_batches(self):
+        for i in range(0, len(self.test_data), self._batchsize):
+
+            if len(self.test_data[i:i + self._batchsize]) < self._batchsize:
+                break  # drop last incomplete batch
+
+            labels_sorted = sorted(self.test_labels[i:i + self._batchsize:], key=len, reverse=True)
+            test_sorted = sorted(self.test_data[i:i + self._batchsize:], key=len, reverse=True)
+            for p in range(len(labels_sorted)):
+                    assert len(labels_sorted[p]) == len(test_sorted[p])
+            yield test_sorted, labels_sorted
+
+    def get_train_size(self):
+        return len(self.train_data)
+
+    def get_val_size(self):
+        return len(self.val_data)
+
+    def get_test_size(self):
+        return len(self.test_data)

helper.py

@@ -0,0 +1,93 @@
+import torch
+import numpy as np
+
+def score_to_modality(scores: torch.Tensor):
+    tensor_list = scores.tolist()
+    modality = []
+    for row in tensor_list:
+        modality.append(row.index(max(row)))
+    return modality
+
+class ValTest:
+    accuracy = []
+
+    def __init__(self, dl_generator, net, trip_dim, batch_size, device, loss_function, num_modes, datasize):
+        self.dl_generator = dl_generator
+        self.net = net
+        self.trip_dim = trip_dim
+        self.batch_size = batch_size
+        self.device = device
+        self.loss_function = loss_function
+        self.num_modes = num_modes
+        self.datasize = datasize
+
+    def run(self):
+
+        correct = 0
+        total = 0
+        val_losses = []
+        total_per_mode = [0] * self.num_modes
+        correct_per_mode = [0] * self.num_modes
+        journeys_eighty_percent_correct = 0
+
+        self.net.eval()  # put net in eval mode
+
+        for data, labels in self.dl_generator():
+
+            self.net.zero_grad()
+            lengths = [len(x) for x in data]
+            for i, elem in enumerate(data):
+               while len(elem) < lengths[0]:
+                   elem.append([-1] * self.trip_dim)
+
+            X = np.asarray(data, dtype=np.float)
+            input_tensor = torch.from_numpy(X)
+            input_tensor = input_tensor.to(self.device)
+
+            output, max_padding_for_this_batch = self.net(input_tensor, lengths)
+
+            for labelz in labels:
+               while len(labelz) < max_padding_for_this_batch:
+                   labelz.append(-1)
+
+            labels_for_loss = torch.tensor(labels) \
+               .view(max_padding_for_this_batch * self.batch_size, -1).squeeze(1).long().to(self.device)
+
+            loss = self.loss_function(output.view(
+               max_padding_for_this_batch * self.batch_size, -1),
+               labels_for_loss)
+            val_losses.append(loss.item())
+
+            for k, journey in enumerate(output):
+                journey_correct = 0
+                predicted = score_to_modality(journey)
+
+                o = 0
+                for o, elem in enumerate(predicted):
+                    if labels[k][o] == -1:
+                        break
+                    total_per_mode[int(labels[k][o])] += 1
+                    if labels[k][o] == predicted[o]:
+                        correct_per_mode[predicted[o]] += 1
+                        correct += 1
+                        journey_correct += 1
+                    total += 1
+                if journey_correct >= (o * 0.80):
+                    journeys_eighty_percent_correct += 1
+
+            mode_statistics = []
+            for k in range(len(correct_per_mode)):
+                if correct_per_mode[k] == 0 or total_per_mode[k] == 0:
+                    mode_statistics.append(0)
+                    continue
+                mode_statistics.append(1 / (total_per_mode[k] / correct_per_mode[k]))
+
+        print('Accuracy: %d %%' % (100 * correct / total))
+        print('%% of journeys at least 80%% correct: %d of %d, %d %%' % (
+            journeys_eighty_percent_correct, self.datasize, (100 * journeys_eighty_percent_correct / self.datasize)))
+        print("Loss: {:.6f}".format(np.mean(val_losses)))
+        print("Mode-correct:")
+        print(total_per_mode)
+        print(mode_statistics)
+
+        self.net.train()

modality_lstm.py

@@ -0,0 +1,64 @@
+import torch
+from torch import nn
+from torch.autograd import Variable
+
+
+class ModalityLSTM(nn.Module):
+    def __init__(self, trip_dimension, output_size, batch_size, hidden_dim, n_layers, gpu, drop_prob, lstm_drop_prob=0.5):
+        super().__init__()
+        self.trip_dimension = trip_dimension
+        self.output_size = output_size
+        self.n_layers = n_layers
+        self.batch_size = batch_size
+        self.hidden_dim = hidden_dim
+        self.on_gpu = gpu
+        self.lstm_drop_prob = lstm_drop_prob
+        self.drop_prob = drop_prob
+
+        self.lstm = nn.LSTM(
+            input_size=self.trip_dimension,
+            hidden_size=self.hidden_dim,
+            num_layers=self.n_layers,
+            batch_first=True,
+            dropout = self.drop_prob,
+            bidirectional=True
+        )
+        self.dropout = nn.Dropout(drop_prob)
+        self.linear_fc = nn.Linear(self.hidden_dim * 2, self.output_size)
+
+
+    def init_hidden(self):
+        # the weights are of the form (nb_layers, batch_size, nb_lstm_units)
+        hidden_a = torch.randn(self.n_layers*2, self.batch_size, self.hidden_dim)
+        hidden_b = torch.randn(self.n_layers*2, self.batch_size, self.hidden_dim)
+
+        if self.on_gpu:
+            hidden_a = hidden_a.cuda()
+            hidden_b = hidden_b.cuda()
+
+        hidden_a = Variable(hidden_a)
+        hidden_b = Variable(hidden_b)
+
+        return (hidden_a, hidden_b)
+
+    def forward(self, input_tensor, lengths):
+        # shape of X: [batch_size, max_seq_len, feature_size]
+
+        # get unpadded sequence lengths (padding: -1)
+        self.hidden = self.init_hidden()
+
+        # pack the padded sequences, length contains unpadded lengths (eg., [43,46,67,121])
+        x_packed = torch.nn.utils.rnn.pack_padded_sequence(input_tensor, lengths, batch_first=True)
+
+        # feed to lstm
+        lstm_out, self.hidden = self.lstm(x_packed.float(), self.hidden)
+
+        # unpack
+        x_unpacked, seq_len = torch.nn.utils.rnn.pad_packed_sequence(lstm_out, batch_first=True)
+
+        out = self.dropout(x_unpacked)
+
+        outs = []  # save all predictions
+        for point in out:
+            outs.append(self.linear_fc(point))
+        return torch.stack(outs, dim=0),max(lengths)

raw_data_loader.py

@@ -0,0 +1,59 @@
+import os
+import pickle
+import pandas as pd
+import datetime
+import sys
+
+from multiprocessing import Pool
+
+def get_labeled_data_as_df(path):
+    trajectory_frames = []
+
+    labelfile = os.path.join(path, "labels.txt")
+    _label_df = pd.read_csv(labelfile,sep="\t",header=0,names=["starttime", "endtime", "mode"],parse_dates=[0,1])
+    _label_df["startdate"] = _label_df["starttime"].dt.date
+    _label_startdate_set = set(_label_df["startdate"])
+
+    datapath = os.path.join(path, "Trajectory")
+    for file in os.listdir(datapath):
+        df = pd.read_csv(os.path.join(datapath,file),
+                         sep=",",
+                         header=None,
+                         skiprows=6,
+                         usecols=[0, 1, 3, 5, 6],
+                         names=["lat", "lon", "altitude", "date", "time"])
+
+        df["datetime"] = pd.to_datetime(df['date'] + ' ' + df['time'])
+        date_of_traj = datetime.datetime.strptime(file[:8],"%Y%m%d").date()
+
+        if date_of_traj in _label_startdate_set:
+            labels_for_date = _label_df[_label_df["startdate"] == date_of_traj]
+
+            def is_in(trajrow):
+                for i, row in labels_for_date.iterrows():
+                    if row["starttime"] <= trajrow["datetime"] <= row["endtime"]:
+                        return row["mode"]
+
+            df["label"] = df.apply(is_in, axis=1)
+
+        trajectory_frames.append(df)
+        print("added", datapath, file)
+    return trajectory_frames
+
+if __name__ == '__main__':
+    '''if len(sys.argv) < 2:
+        print("Usage: raw_data_loader.py /path/to/geolife/Data/")
+        exit(-1)'''
+    path = 'D:\Geolife Trajectories 1.3\Geolife Trajectories 1.3\Data'
+    traj_with_labels_paths = []
+    for file in os.listdir(path):
+        currfile = os.path.join(path, file)
+        if os.path.isdir(currfile):
+            if "labels.txt" not in os.listdir(currfile):
+                continue
+            traj_with_labels_paths.append(currfile)
+
+    with Pool(3) as p:
+        traj_frames = p.map(get_labeled_data_as_df, traj_with_labels_paths)
+
+    pickle.dump(traj_frames, open( "data/raw_labeled.pkl", "wb"))