## Inspiration

Everyone gets tired waiting for their large downloads to complete. BitTorrent is awesome, but you may not have a bunch of peers ready to seed it. Fastify, a download accelerator as a service, solves both these problems and regularly enables 4x download speeds.

## What it does

The service accepts a URL and spits out a `.torrent` file. This `.torrent` file allows you to tap into Fastify's speedy seed servers for your download.

We even cache some downloads so popular downloads will be able to be pulled from Fastify even speedier!

Without any cache hits, we saw the following improvements in download speeds with our test files:

```
|                   | 512Mb    | 1Gb    | 2Gb     | 5Gb     |
|-------------------|----------|--------|---------|---------|
| Regular Download  | 3 mins   | 7 mins | 13 mins | 30 mins |
| Fastify           | 1.5 mins | 3 mins | 5 mins  | 9 mins  |
|-------------------|----------|--------|---------|---------|
| Effective Speedup | 2x       | 2.33x  | 2.6x    | 3.3x    |

```

*test was performed with slices of the ubuntu 16.04 iso file, on the eduroam network*

## How we built it

Created an AWS cluster and began writing Go code to accept requests and the front-end to send them. Over time we added more workers to the AWS cluster and improved the front-end. Also, we generously received some well-needed Vitamin Water.

## Challenges we ran into

The BitTorrent protocol and architecture was more complicated for seeding than we thought. We were able to create `.torrent` files that enabled downloads on some BitTorrent clients but not others.

Also, our "buddy" (*\*cough\** James *\*cough\**) ditched our team, so we were down to only 2 people off the bat.

## Accomplishments that we're proud of

We're able to accelerate large downloads by 2-5 times as fast as the regular download. That's only with a cluster of 4 computers.

## What we learned

Bittorrent is tricky. James can't be trusted.

## What's next for Fastify

More servers on the cluster. Demo soon too.
## Inspiration

You use Apple Music. Your friends all use Spotify. But you're all stuck in a car together on the way to Tahoe and have the perfect song to add to the road trip playlist. With TrainTrax, you can all add songs to the same playlist without passing the streaming device around or hassling with aux cords.

Have you ever been out with friends on a road trip or at a party and wished there was a way to more seamlessly share music? TrainTrax is a music streaming middleware that lets cross platform users share music without pulling out the aux cord.

## How it Works

The app authenticates a “host” user sign through their Apple Music or Spotify Premium accounts and let's them create a party where they can invite friends to upload music to a shared playlist. Friends with or without those streaming service accounts can port through the host account to queue up their favorite songs. Hear a song you like? TrainTrax uses Button to deep links songs directly to your iTunes account, so that amazing song you heard is just a click away from being yours.

## How We Built It

The application is built with Swift 3 and Node.js/Express. A RESTful API let’s users create parties, invite friends, and add songs to a queue. The app integrates with Button to deep link users to songs on iTunes, letting them purchase songs directly through the application.

## Challenges We Ran Into

• The application depended a lot on third party tools, which did not always have great documentation or support.
• This was the first hackathon for three of our four members, so a lot of the experience came with a learning curve. In the spirit of collaboration, our team approached this as a learning opportunity, and each member worked to develop a new skill to support the building of the application. The end result was an experience focused more on learning and less on optimization.
• Rain.

## Accomplishments that we're proud of

• SDK Integrations: Successful integration with Apple Music and Spotify SDKs!
• Button: Deep linking with Button
• UX: There are some strange UX flows involved with adding songs to a shared playlist, but we kicked of the project with a post-it design thinking brainstorm session that set us up well for creating these complex user flows later on.
• Team bonding: Most of us just met on Friday, and we built a strong fun team culture.

## What we learned

Everyone on our team learned different things.

## What's next for TrainTrax

• A web application for non-iPhone users to host and join parties
• Improved UI and additional features to fine tune the user experience — we've got a lot of ideas for the next version in the pipeline, including some already designed in this prototype: [TrainTrax prototype link](https://invis.io/CSAIRSU6U#/219754962_Invision-_User_Types)
## Inspiration

I like looking at things. I do not enjoy bad quality videos . I do not enjoy waiting. My CPU is a lazy fool. He just lays there like a drunkard on new years eve. My poor router has a heart attack every other day so I can stream the latest Kylie Jenner video blog post, or has the kids these days call it, a 'vlog' post.

CPU isn't being effectively leveraged to improve video quality. Deep learning methods are in their own world, concerned more with accuracy than applications. We decided to develop a machine learning application to enhance resolution while developing our models in such a way that they can effective run without 10,000 GPUs.

## What it does

We reduce your streaming bill. We let you stream Kylie's vlog in high definition. We connect first world medical resources to developing nations. We make convert an unrecognizeable figure in a cop's body cam to a human being. We improve video resolution.

## How I built it

Wow. So lots of stuff.

Web scraping youtube videos for datasets of 144, 240, 360, 480 pixels. Error catching, thread timeouts, yada, yada. Data is the most import part of machine learning, and no one cares in the slightest. So I'll move on.

## ML stuff now. Where the challenges begin

We tried research papers. Super Resolution Generative Adversarial Model [link](https://arxiv.org/abs/1609.04802). SRGAN with an attention layer [link](https://arxiv.org/pdf/1812.04821.pdf). These were so bad. The models were to large to hold in our laptop, much less in real time. The model's weights alone consisted of over 16GB. And yeah, they get pretty good accuracy. That's the result of training a million residual layers (actually *only* 80 layers) for months on GPU clusters. We did not have the time or resources to build anything similar to these papers. We did not follow onward with this path.

We instead looked to our own experience. Our team had previously analyzed the connection between image recognition and natural language processing and their shared relationship to high dimensional spaces [see here](https://arxiv.org/abs/1809.05286). We took these learnings and built a model that minimized the root mean squared error as it upscaled from 240 to 480 px.

However, we quickly hit a wall, as this pixel based loss consistently left the upscaled output with blurry edges. In order to address these edges, we used our model as the Generator in a Generative Adversarial Network. However, our generator was too powerful, and the discriminator was lost.

We decided then to leverage the work of the researchers before us in order to build this application for the people. We loaded a pretrained VGG network and leveraged its image embeddings as preprocessing for our discriminator. Leveraging this pretrained model, we were able to effectively iron out the blurry edges while still minimizing mean squared error.

Now model built. We then worked at 4 AM to build an application that can convert videos into high resolution.

## Accomplishments that I'm proud of

Building it good.

## What I learned

Balanced approaches and leveraging past learning

## What's next for Crystallize

Real time stream-enhance app.