SDSC/open-pulse-hackathon-data-analysis huggingface dataset:
Repository: sid030sid/self-sovereign-ecolens
Primary language: JavaScript

# Self-sovereign Ecolens

## About
Ecolens is a mobile app for students to gain points for chosing environmentally friendly meals offered on-campus. These ``eco-points`` can be used for rewards, such as discounts for the next meals or little prices. Besides, this financial incentive, Ecolens uses gamification to additionally motivate students to chose the environemntally for facilitating (Read more on the Ecolens Project [here](https://zeroemission.group/ecolens/)). This repo provides the technical infrastructure to issue and verify eco-points using the Self-Sovereign Identiy paradigm that guranteeis the sovereignity of students over their private data while guranteeing the functionality of the ecolens application.

## Repo overview
- Branch `issuer-web-app` contains a web app that issuers of eco-points can use during the conduct of their ordinary business. issuers of eco-points are restaurants or food stands on-campus that sell meals to students and use Ecolens to reward them for chosing their ecologically friendly meal choices. 
- Branch `verfifier-web-app` contains an examplary web app that can be used by verifiers of eco-points. In general, verifiers of eco-points are legal entities that accept eco-points to give out discounts, prizes, or any other financial incentives. The examplary web app is for restaurants that allow their customers to buy meals with eco-points, thus incentivising environmentally friendly food consumption.+
- **NOTE**: the code in the folders `issuer` and `verifier` should be ignored!

## How to...
### ... set up?
TBA

### ... start web app for issuer and verifier of eco-point Verifiable Credentials?
TBA

## FAQ
### Why use Ecolens as a student?
Get Eco-points which can be used to get financial rewards for eating ecofriendly meals on-campus. Share your sustainable eating habit to your fellow students to encourage them to eat ecofriendly as well...without comprising your privacy thanks to Ecolen's usage of Zero Knowledge Proofs.

### Why use Ecolens as a restaurant?
Brandy your restaurant to be eco-friendly and an advocate of a sustainable future.

### Why accept eco-points awarded through Ecolens for discounts, prices, and other financial incentives?
By accepting eco-points, their owners have more options to use their eco-points for financial rewards, motivating them to continue eating ecofriendly. Moreover, the more options there are to use eco-points in daily business processes, the more people will join Ecolens and thus the movement of eating stustainbly. Therefore, legal entities accepting eco-points for discounts, prices, or other financial incentives
Repository: stefanoviel/ubsChallenge
Primary language: Jupyter Notebook

# UBSolver
In this challenge we have tried to solve the problem proposed by UBS about the Entity Resolution Challenge. <br>
Our solution is very time efficient and has a very good performance on the test dataset provided (we got a F-score of 0.87).

## Code structure
The code can be is in the main.ipynb file and it includes:
- A cleaning section: we have used some rules to clean the data and reduce the number of samples.
- A processing section: we compute some similarity metrics that we are then going to use to match the samples.
- A matching section: we match together similar samples with a graph-based approach.

## The idea
The main ideas that we have used are:
- Since we are in a case with lots of data (bilions!) we need to reduce them to avoid too high computational costs. For this reason we matched together samples that are clearly the same (i.e. IBAN, name, address, etc.). This was inspired by the observatin that almost all the transaction from a common entity matched on at least one of the features.<br>
- For every pair of matched elements we compute the Levenshtein similarity (all the features are strings) is computed for every feature. <br>
- We trained a Neural Network to predict if two samples are the same or not based on the similarity scores computed before. This neural network is very simple since it's a multi-layer perceptron with 2 hidden layers (100 - 50 neurons). <br>
- Finally we created a graph on the test set and we used the trained Neural Network to match together samples that are similar. Another important observation which allowed us to efficiently create the set was to discard the values which appeared too often as they weren't significant to match the entities. <br>
- Each strongly connected component of the graph is an entity representing a person or a company.

## The team
Our team:
- Matteo Santelmo matteo.santelmo@epfl.ch
- Alessandro Dalbesio alessandro.dalbesio@epfl.ch
- Stefano Viel stefano.viel@epfl.ch
Repository: swittum/SBB_Challenge_LauzHack_2023
Primary language: Python

# SBB Challenge LauzHack 2023
## Enhancing Mobility With Interconnected Solutions
This repository has been created in the course of the LauzHack 2023 Hackathon hosted by EPFL in Lausanne. It has been created in strong cooperation with @fwalcher. To run the code, clone the repository to your local computer and run
```bash
$foo@bar:~$ pip -r install requirements.txt
```
in the command line. You will then be able to execute the main.py script by running
```python
python3 main.py
```
The idea of this project is to convince frequent car drivers in Switzerland to partly switch to public transport whenever it is faster to drive to an SBB Park&Ride station by car, and then continue the journey by train.
Repository: tferracina/agriviewer
Description: LauzHack 2024 Submission
Primary language: Jupyter Notebook

# Agriview

## The intersection of computer vision and LLM's. A chatbot designed to convey information on fields using semantic segmentation on satelite imagery. 

Agriview is an agricultural intelligence platform that leverages satellite imagery, computer vision, and large language models to provide actionable insights for farmers, traders or land surveyors.

### Problem Statement

Agricultural decision-making requires complex data analysis from satellite imagery. Agriview simplifies this process by translating complex satellite data into understandable, actionable insights.


### Technologies

 - Satellite Data Acquisition: Copernicus Browser (Sentinel-2)
 - Segmentation model: Panoptic Segmentation of Satellite Image Time Series with Convolutional Temporal Attention Networks (https://github.com/VSainteuf/utae-paps?tab=readme-ov-file)
 - Image Processing: Rasterio
 - AI Interaction: LlamaIndex
 - Computer Vision: Custom crop field segmentation model
 - Language Model: LLAMA 8B Instruct

### Key Features
- Intelligent Data Parsing
- Converts plain text instructions into computational variables
- Uses LLAMA 8B Instruct model for precise instruction parsing

#### Satellite Image Analysis

- Segments crop fields from satellite time series data
- Identifies and masks different crop types
- Calculates agricultural metrics (e.g., moisture index)

#### Retrieval-Augmented Generation (RAG)

- Stores and references previous query information
- Enables multi-year comparative analysis

### Workflow

- Input: User provides a natural language query
- Parsing: LLAMA model transforms query into actionable variables
- Image Processing: Computer vision model analyzes satellite imagery
- Metric Calculation: Extracts relevant agricultural metrics
- Insight Generation: LLM provides contextualized, actionable insights

#### Example Use Case
Query: "What's the agricultural outlook for wheat in Kentucky this season?"

Response: "The average moisture NDMI of wheat fields at this time of year in Kentucky is [X], indicating a high yield compared to previous years where it was [Y]."


### Future Roadmap

 - Enhanced segmentation models
 - Expanded crop and region coverage
 - More advanced predictive analytics
 - Time series data for historic analysis
Repository: verooo0/Lauzhack_pack
Primary language: Python

# Lauzhack_pack

This project for the LauzHack 2024 from the sponsor BOBST consists in a 'Mini Smart Factory' that controls the production and the quality of the product itself.

It's based on a Raspberry pi 5 and it uses an IR sensor, ultrasound sensor and a Servo motor to simulate a production line.
Repository: walid-as/sbb-ghost-rider
Description: LauzHack challenge 2025:
Primary language: Kotlin

# GhostRider - Anonymous Ticket System

A complete Android demonstration of an anonymous ticket issuance and verification system using Schnorr-style signatures and NFC communication.

## Features

- **CLIENT MODE**: Generate anonymous tickets with device-bound secrets
- **INSPECTOR MODE**: Verify tickets via NFC using zero-knowledge proofs
- **Cryptographic Protocol**: Schnorr-like signature scheme with challenge-response
- **NFC Communication**: HCE (client) and Reader Mode (inspector)
- **Secure Storage**: Android KeyStore + EncryptedSharedPreferences

## Architecture

### Cryptographic Flow

1. **Ticket Generation (Client)**:
   - Generate random nonce (32 bytes)
   - Compute `ticketId = SHA-256(nonce)`
   - Derive secret `acc` from device-bound ECDSA key signature
   - Compute public key `P = g^acc mod p`
   - Store ticket securely

2. **Verification (Inspector)**:
   - Inspector generates challenge `c = SHA-256(timestamp || lat || lon)`
   - Sends challenge via NFC to client
   - Client responds with Schnorr signature `(S, R)`:
      - `R = g^n mod p` (n is random)
      - `S = (n + acc * c) mod q`
   - Inspector verifies: `g^S ≡ R * P^c`

### Schnorr Parameters

- **p**: RFC 3526 2048-bit MODP Group 14 prime (safe prime)
- **g**: 2

### NFC Protocol

**Client (HCE Service)**:
- AID: `F0010203040506`
- Commands:
   - `INS=0xA1`: Returns ticketId
   - `INS=0xA2`: Receives challenge, returns `(S, R)`

**Inspector (Reader Mode)**:
- Sends SELECT AID
- Requests ticketId
- Sends challenge
- Receives and verifies signature

## Build & Run

### Prerequisites
- Android Studio Hedgehog or later
- Two physical Android devices with NFC (API 26+)
- NFC enabled on both devices

### Setup

1. **Clone/Create Project**

2. **Build**

3. **Install on Both Devices**


## Testing Two-Device NFC Flow

### Device 1 (Client):

1. Open app → CLIENT MODE
2. Tap "Generate New Ticket"
3. Tap "Add to Wallet" on a ticket
4. **Leave app open** (HCE service must be active)

### Device 2 (Inspector):

1. Open app → INSPECTOR MODE
2. Tap "Start NFC Reader"
3. Hold Device 2 back-to-back with Device 1
4. Wait 2-5 seconds for NFC exchange
5. View verification result (VALID/INVALID)

### Local Demo (Single Device):

1. CLIENT MODE → "Run Local Demo (No NFC)"
2. This simulates the full protocol locally to prove correctness

## Key Files

- **MainActivity.kt**: Navigation and app entry
- **ClientScreen.kt**: Ticket generation and wallet UI
- **InspectorScreen.kt**: NFC reader and verification UI
- **HceService.kt**: NFC HCE APDU handler (client side)
- **NfcReader.kt**: NFC reader mode implementation (inspector side)
- **CryptoHelper.kt**: Schnorr parameters, key derivation, signature generation/verification
- **Storage.kt**: Secure ticket storage (EncryptedSharedPreferences)
- **Models.kt**: Data classes

## Simulated Wallet

**Current Implementation**: When "Add to Wallet" is tapped, the ticket is marked in local storage and becomes the active ticket for NFC presentation.

## License

MIT License - Demo purposes only
Repository: wesleymth/LauzHack2023-SpeakerNotes
Primary language: Jupyter Notebook

# speaker-notes

Automatically transcribe the audio and annotate each slide of a presentation with the speaker's commentary, from zoom recordings of the presentation (mp4 file format), as well as the pdf of the presentation.

```
conda create --name lauz python=3.11.5
conda activate lauz
pip install PyPDF2
pip install moviepy
pip install matplotlib, scipy
pip install torch torchvision torchaudio
pip install 'transformers[torch]'
pip install pdfminer
pip3 install pdfminer-six
pip install pytesseract
pip install openai==0.28
# Check if transformers download worked
python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('we love you'))"
```


# Docker
```
docker build -t lauzhack2023/speaker-notes:0.1.0 .
docker run -it -d --name speaker_notes_container -v $(pwd):/app lauzhack2023/speaker-notes:0.1.0 /bin/bash
docker exec -it speaker_notes_container /bin/bash
python audio_transcribe_scene_detect.py  # How to run a file
```
Repository: zafirazz/LHubs
Primary language: Python

# AML Casefile Generation System

An intelligent, multi-agent system for automated AML casefile generation from client data uploads.

## Demo Video Link
https://drive.google.com/file/d/105WkcvLSACd-18EAE9pm7gT37QQnMZac/view?usp=sharing

## Quick Start

```bash
# Install dependencies
pip install -r requirements.txt

# Set up environment
cp .env.example .env
# Edit .env with your configuration

# Run database migrations
alembic upgrade head

# Start the system
python -m src.main
```

## Architecture

See [ARCHITECTURE.md](./ARCHITECTURE.md) for detailed system design.

## Project Structure

```
LHubs/
├── src/
│   ├── agents/          # Agent implementations
│   ├── orchestrator/    # Workflow orchestration
│   ├── tools/           # Agent tools and utilities
│   ├── services/        # Core services (DB, cache, etc.)
│   └── workflows/       # Workflow definitions
├── configs/             # Configuration files
├── prompts/             # LLM prompts and templates
├── tests/               # Test suites
├── scripts/             # Utility scripts
└── infrastructure/      # Docker, K8s configs
```

## Development

```bash
# Run tests
pytest

# Format code
black src/
ruff check src/

# Type check
mypy src/
```

## License

Proprietary