This course will have five broad modules: (1) Human Sensing -- covering location, gesture, activity, interaction, and context sensing to understand human behavior and intent; (2) Environment Sensing -- covering how devices perceive ambient conditions, surroundings, and events beyond the human body; (3) Sensor Foundation Models -- covering large pre-trained models for sensor data and the growing role of LLMs in sensing pipelines; (4) Systems and Software for Ubiquitous Computing -- covering the operating systems, networking, and hardware substrates that make pervasive sensing and computing possible; and (5) Security and Privacy Aspects of Ubiquitous Computing -- covering the confidentiality, ethics, and trust models associated with all these sensing paradigms. We'll look into different sensors and devices, various sensing modalities ranging from locomotive sensing to wireless, acoustic, and RF sensing, how they get integrated, how we can develop low-cost, low-resource learning models to process the data collected from those sensors, how the information is interpreted, how do we infer causality, and finally, how such various methods are combined to infer the final decision.

The field is also undergoing a rapid transformation, and this course will introduce you to where it is heading. Just as large language models (LLMs) have reshaped how machines understand and generate text, a parallel shift is happening in sensing: researchers are now building sensor foundation models -- large pre-trained models on time-series, IMU, RF, and acoustic data that can generalize across tasks, devices, and users with minimal fine-tuning, much like foundation models did for vision and language. We'll examine how such models are trained, how they handle heterogeneous, multimodal, and noisy sensor streams, and how techniques like self-supervised learning, cross-modal distillation, and transfer learning reduce the traditional dependence on large labeled datasets in ubiquitous computing. We'll also look at the emerging role of LLMs within sensing pipelines themselves -- using them for context reasoning, natural-language explanation of sensed activities, few-shot or zero-shot activity labeling, synthetic sensor-data generation, and as reasoning agents that fuse multimodal signals with world knowledge to make more human-understandable, generalizable inferences. Alongside this, we'll discuss the practical realities of deploying such large models on resource-constrained edge devices -- model compression, quantization, on-device versus edge-cloud split inference -- and the new privacy, hallucination, and trust challenges that come with bringing generative AI into personal, always-sensing systems.

Additionally, you'll also do some hands-on experiments to program and run models on devices like smartphones and embedded sensors to extract human behavior and contextual information from the collected data. In this process, you'll also learn how to handle real-time noisy sensor data and apply machine learning, deep learning, and where relevant, foundation-model-based approaches on top of them.

1. Ubiquitous Computing: Smart Devices, Environments and Interactions, by Stefan Poslad, Wiley, ISBN: 978-0470035603
2. Ubiquitous Computing Fundamentals, by John Krumm, Chapman and Hall/CRC, ISBN: 978-1420093605
3. Research papers from conferences (ACM MobiSys, ACM SenSys, ACM/IEEE IPSN, ACM MobiCom, IEEE PerCom, ACM CHI, ACM MobileHCI) and Journals (ACM IMWUT, ACM TOSN, ACM TOIT, IEEE TMC)

This course will include two hackathons, each built around an open-ended problem statement and an accompanying dataset released at the start of the hackathon window. Students will work in groups throughout the course, and each hackathon will run on the following schedule:

Hackathon 1: Deadline before the mid-semester exam
Hackathon 2: Deadline before the end-semester exam

Submission Requirements
For each hackathon, every group must submit (i) their complete solution/code, and (ii) a 5-page report covering their methodology and results -- including problem understanding, methodology and design decisions, experimental setup, results, and a discussion of limitations.

Evaluation Criteria
Submissions will be graded on: (1) innovativeness of the proposed solution, (2) achieved performance on the given dataset/task, and (3) quality of the report, including clarity, rigor, and honest discussion of results.

Verification of Results
To ensure that reported results are genuine and reproducible, each group's submission will be verified through (i) their git commit history, which should reflect the actual development and experimentation process, and (ii) a live presentation/viva, where groups will be asked to walk through and defend their approach and results.

Plagiarism Policy
All submissions -- code and reports -- must be the original work of the submitting group. Copying code, report text, or results from other groups, previous years' submissions, online repositories, or published papers without explicit attribution constitutes plagiarism and will be dealt with as per institute academic integrity guidelines. Use of standard open-source libraries and publicly available pre-trained models is permitted, but must be clearly cited in the report.

AI-Usage Policy
Students may use AI tools (e.g., LLM-based coding assistants, chatbots) to support their work -- for instance, for code debugging, boilerplate generation, or improving report writing. However, the core methodology, experimental design, and interpretation of results must reflect the group's own understanding. Any significant use of AI tools must be disclosed in a short "AI Usage" note at the end of the report, specifying the tool used and its purpose. Reports must not contain fabricated, hallucinated, or unverified results; any such instance will be treated as a serious academic integrity violation on par with plagiarism.

Group Accountability
Groups are collectively responsible for their submissions. If plagiarism or undisclosed AI misuse is found in any part of a group's submission, the entire group -- not just the individual member responsible -- will be held accountable under the institute's academic integrity policy.

Similarity Checking
All submitted reports and code will be run through similarity-detection tools to check for overlap with other groups' submissions, prior years' work, and online sources. This process will be disclosed to students upfront, and any submission flagged for high similarity without valid justification (e.g., proper citation) will be investigated under the plagiarism policy above.

Special Recognitions
Top-performing groups from each hackathon will be recognised separately, beyond the regular course grading. Recognition may include special certificates of excellence, and where the solution demonstrates sufficient novelty and rigor, the instructor may work with the group to shape it into a submission for a top-tier conference. If such a paper is accepted and at least one of the group members is on the rolls of IIT Kharagpur at the time, the course will provide partial travel support for one member of the group to attend the conference and present the work.