### Inspiration

The way research is funded is harmful to science — researchers seeking science funding can be big losers in the equality and diversity game. We need a fresh ethos to change this.

### What it does

Connexsci is a grant funding platform that generates exposure to undervalued and independent research through graph-based analytics. We've built a proprietary graph representation across 250k research papers that allows for indexing central nodes with highest value-driving research. Our grant marketplace allows users to leverage these graph analytics and make informed decisions on scientific public funding, a power which is currently concentrated in a select few government organizations. Additionally, we employ quadratic funding, a fundraising model that democratizes impact of contributions that has seen mainstream success through <https://gitcoin.co/>.

### How we built it

To gain unique insights on graph representations of research papers, we leveraged Cohere's NLP suite. More specifically, we used Cohere's generate functionality for entity extraction and fine-tuned their small language model with our custom research paper dataset for text embeddings. We created self-supervised training examples where we fine-tuned Cohere's model using extracted key topics given abstracts using entity extraction. These training examples were then used to fine-tune a small language model for our text embeddings.

Node prediction was achieved via a mix of document-wise cosine similarity, and other adjacency matrices that held rich information regarding authors, journals, and domains.

For our funding model, we created a modified version of the Quadratic Funding model. Unlike the typical quadratic funding systems, if the subsidy pool is not big enough to make the full required payment to every project, we can divide the subsidies proportionately by whatever constant makes the total add up to the subsidy pool's budget. For a given scenario, for example, a project dominated the leaderboard with an absolute advantage. The team then gives away up to 50% of their matching pool distribution so that every other project can have a share from the round, and after that we can see an increase of submissions.

The model is then implemented to our Bounty platform where organizers/investors can set a "goal" or bounty for a certain group/topic to be encouraged to research in a specific area of academia. In turn, this allows more researchers of unpopular topics to be noticed by society, as well as allow for advancements in the unpopular fields.

### Challenges we ran into

The entire dataset broke down in the middle of the night! Cohere also gave trouble with semantic search, making it hard to train our exploration model.

### Accomplishments that we're proud of

Parsing 250K+ publications and breaking it down to the top 150 most influential models. Parsing all ML outputs on to a dynamic knowledge graph. Building an explorable knowledge graph that interacts with the bounty backend.

### What's next for Connex

Integrating models directly on the page, instead of through smaller microservices.
## Inspiration

During our brainstorming phase, we cycled through a lot of useful ideas that later turned out to be actual products on the market or completed projects. After four separate instances of this and hours of scouring the web, we finally found our true calling at QHacks: building a solution that determines whether an idea has already been done before.

## What It Does

Our application, called Hack2, is an intelligent search engine that uses Machine Learning to compare the user’s ideas to products that currently exist. It takes in an idea name and description, aggregates data from multiple sources, and displays a list of products with a percent similarity to the idea the user had. For ultimate ease of use, our application has both Android and web versions.

## How We Built It

We started off by creating a list of websites where we could find ideas that people have done. We came up with four sites: Product Hunt, Devpost, GitHub, and Google Play Store. We then worked on developing the Android app side of our solution, starting with mock-ups of our UI using Adobe XD. We then replicated the mock-ups in Android Studio using Kotlin and XML.

Next was the Machine Learning part of our solution. Although there exist many machine learning algorithms that can compute phrase similarity, devising an algorithm to compute document-level similarity proved much more elusive. We ended up combining Microsoft’s Text Analytics API with an algorithm known as Sentence2Vec in order to handle multiple sentences with reasonable accuracy. The weights used by the Sentence2Vec algorithm were learned by repurposing Google's word2vec ANN and applying it to a corpus containing technical terminology (see Challenges section). The final trained model was integrated into a Flask server and uploaded onto an Azure VM instance to serve as a REST endpoint for the rest of our API.

We then set out to build the web scraping functionality of our API, which would query the aforementioned sites, pull relevant information, and pass that information to the pre-trained model. Having already set up a service on Microsoft Azure, we decided to “stick with the flow” and build this architecture using Azure’s serverless compute functions.
After finishing the Android app and backend development, we decided to add a web app to make the service more accessible, made using React.

## Challenges We Ran Into

From a data perspective, one challenge was obtaining an accurate vector representation of words appearing in quasi-technical documents such as Github READMEs and Devpost abstracts. Since these terms do not appear often in everyday usage, we saw a degraded performance when initially experimenting with pretrained models. As a result, we ended up training our own word vectors on a custom corpus consisting of “hacker-friendly” vocabulary from technology sources. This word2vec matrix proved much more performant than pretrained models.

We also ran into quite a few issues getting our backend up and running, as it was our first using Microsoft Azure. Specifically, Azure functions do not currently support Python fully, meaning that we did not have the developer tools we expected to be able to leverage and could not run the web scraping scripts we had written. We also had issues with efficiency, as the Python libraries we worked with did not easily support asynchronous action. We ended up resolving this issue by refactoring our cloud compute functions with multithreaded capabilities.

## What We Learned

We learned a lot about Microsoft Azure’s Cloud Service, mobile development and web app development. We also learned a lot about brainstorming, and how a viable and creative solution could be right under our nose the entire time.
On the machine learning side, we learned about the difficulty of document similarity analysis, especially when context is important (an area of our application that could use work)

## What’s Next for Hack2

The next step would be to explore more advanced methods of measuring document similarity, especially methods that can “understand” semantic relationships between different terms in a document. Such a tool might allow for more accurate, context-sensitive searches (e.g. learning the meaning of “uber for…”). One particular area we wish to explore are LSTM Siamese Neural Networks, which “remember” previous classifications moving forward.
## Inspiration Behind Tangle ⚛️

The idea for Tangle emerged from a recognition that traditional networking methods, such as LinkedIn profiles, have remained static, even as large in-person events like Hack the North make a strong comeback. We saw an opportunity to reimagine how people connect by creating a more dynamic and visual way of representing relationships formed at events. Tangle aims to bridge the gap by providing an interactive web app that helps participants remember, revisit, and reinforce connections made during events, ensuring those relationships don’t just fade into the background.🤝

## How We Built Tangle 🛠️

Tangle is a web app powered by React for the front end and Convex for the back end, with the entire platform hosted on Vercel. We used a GoDaddy domain to make Tangle easily accessible to all users.🌐

Our backend, built with Convex, integrates a vector embedding search powered by Cohere. This allows us to offer advanced search functionality that helps users locate people they’ve met based on attributes and interactions.

On the front end, we designed a simple yet intuitive user interface in React, focusing on ease of navigation. The landing page introduces users to Tangle, while the home page allows them to search for individuals or features related to people they've met at the event. The query is sent to the backend, where it’s processed, and the results are returned in real-time.⚡️

## Challenges We Overcame Building Tangle 🚧

**Design Challenges 🎨**
One of our main challenges was creating a platform that caters to different event attendees—hackers, recruiters, and speakers—all of whom have different goals. Designing Tangle to meet the needs of all these groups while maintaining a cohesive user experience required careful planning and iteration.

**Vector Embeddings 🧠**
A technical challenge was mastering the use of vector embeddings. These embeddings were critical for enabling intelligent search functions within Tangle. We invested considerable time in optimizing the embedding process to accurately capture the nuanced relationships between event attendees.

**Personal Challenges 💪**
Balancing external commitments and the time pressure of the hackathon was no easy feat. At one point, we experienced challenges leading to a demotivating lull 10 hours prior to submissions, but we pushed through as a team in the final hours to finish strong.

## Accomplishments We Celebrate at Tangle 🎉

* Successfully integrating Cohere’s vector embeddings for advanced semantic search within our app.
* Mastering and utilizing Convex to build a robust and efficient backend.
* Designing a user-friendly interface.
* Overcoming personal time management challenges to deliver a working, innovative platform within the hackathon’s time constraints.

## Lessons Learned from Tangle's Journey 📚

**The Importance of Planning 📝**
One of the key takeaways from building Tangle was the necessity of meticulous planning, especially regarding user flow and system architecture. Diving straight into coding without first understanding how users would interact with our app resulted in some avoidable setbacks and rework. We learned that investing time upfront in planning leads to a more streamlined and efficient development process.

**Simplifying Systems 🧩**
We initially overcomplicated parts of our application, which led to inefficiencies. Simplifying and focusing on the core functionalities of Tangle allowed us to optimize the system and deliver a better user experience.