DEV Community: Johnson Lin

A Tour of Contenda Studio

Johnson Lin — Fri, 04 Aug 2023 00:00:00 +0000

We’re really excited to launch Contenda Studio, a new way to stretch your content further!

Contenda Studio differs from our previous one-shot model, which generated one large blog from one video in its entirety. The goal here is to break down your content into building blocks you can use to rebuild something new. Since the process is a bit more involved now, I want to walk through an example to get you started on using Contenda Studio for your workflow.

1. Sources

The first step you’ll take is not too different from our previous workflow. You’ll still need to upload a source. You can still submit the usual: YouTube, Twitch, or just plain downloadable URLs. It’ll take about 30 minutes to process a video, give or take. We’ll send you an email when it’s ready to use for Contenda Studio.

For the purpose of this tutorial, we’ll be using the podcast The Dev Morning Show (At Night), specifically the episode - The Mixed Reality of a Dev Advocate with Cami Williams, Engineering Manager at Meta.

As an aside: You can now also submit text content, not just video! Feel free to just copy and paste documents, articles, landing pages, of any size and we’ll also process them. Text sources are generally ready to use in roughly 10 minutes. For the scope of this tutorial, we’ll focus on just getting something out of our video.

2. Templates

After we’ve submitted our sources and have gotten the email notification that they’re ready to use, we can jump into Contenda Studio!

First, we need to decide what kind of output we want. We currently have 4 templates for you to choose from:

📖 Tutorial
🤝 Handshake
💬 Q & A
📃 Recap

We’re going to create a summary of some of the important things that were said in this video.

3. Topics

Next, we’ll be dropped into the actual interface of Contenda Studio. On the left, you’ll be able to select the source you want to work with.

After you load a source, you’ll see all of its topics here on the left.

These are your topics! We’ve broken down your content into smaller chunks and analyzed the themes and some of the key points. If you click on a tab, it’ll open the full card and that’s where you can read the key points we’ve identified in that topic to give you a fuller idea of what’s discussed in that chunk of your source.

Give each topic a good read (and all the key points if you’d like). We’ll be using them in the next step which actually generates the text you want.

4. Custom Voice

As a creator personally, I care a lot about how to present myself and what I produce. I often mull over a lot of my word choices, and a lot of the base AI models out there in the world produce text that I would never personally write. That’s why Contenda Studio added the ability to provide sample text, so that we can be much closer to your own voice!

Click on the “Customization” tab below the title and it’ll open up a little drawer with a text box for you to put a sample of your writing.

For the sake of this tutorial, let’s do something extreme. I googled Olde English and took the first poem I found.

Disclaimer: I have no idea about the differences between Olde and Middle and other Englishes

Whan that aprill with his shoures soote

The droghte of march hath perced to the roote,

And bathed every veyne in swich licour

…

It goes on for a couple more lines, but honestly, I don’t even understand the first three lines here. Regardless, we now should be expecting Olde English sounding text in our final output.

5. Generate Each Segment

Drag any topics you want and drop them into the relevant sections. Contenda Studio tries to keep it cohesive so your output will look better if you generate each paragraph in order. In this example, I want to create a post about mixed reality. For the introduction I’ll still use the section about who’s speaking on this episode.

Now you’re ready to click “Generate” on each segment! It’ll produce the paragraph based on the topics you dragged in.

Tip: Not loving the output here? You can click “Generate” again to get another attempt at the paragraph

Next, we’ll do the same with the body paragraphs. I’ll take all the topics that touch on mixed reality.

If you wanted to add another body paragraph, you can click this button below your last body paragraph as many times as you want.

6. Edit

Once you feel like you have a good baseline of the content you want to work with, click the “Finish in Editor” button.

It’ll take you to the Contenda Studio editor, where you can really tweak the output until it’s in a state that you’re happy with! From there, you can export as a Markdown file or just copy it to share/publish wherever you’d like.

Personally, I’m loving this as is. They’re referring to augmented reality as another realm! The idea of a bunch of knights from that era putting on a VR headset and getting freaked out that they were “transported” to “another realm” really cracked me up for longer than I’d like to admit.

Share please 👉👈

And that’s a deeper dive into how you can use Contenda Studio! Made something you love? Got ideas for a template you’d like to use? We’d love to hear from you! You can tweet us at @ContendaCo.

Customize code detail, overall length, and headings

Johnson Lin — Tue, 20 Jun 2023 00:00:00 +0000

Last week we announced the ability to override some of our default parameters through the API and released our prompts for inspiration.

Today we’re going to be following up on it and exploring some of the other parameters in more detail. We understand that content is subjective, so our base model is meant to give you a good starting point. But to help you get to a blog that satisfies your needs, I’m going to be going over how you can further customize things like code detail, overall length, and headings. We’ll be using the same video as last time (Nicholas Renotte’s video: Building a Neural Network with PyTorch in 15 Minutes).

Code Similarity Threshold

The parameter code_similarity_score_threshold is how we trim down on redundant code snippets. After we extract all the text from a video and pull together all the code snippets, we check them against each other since often we’re just building on top of the same code. If there’s a significant overlap between adjacent code snippets (defined by the cosine similarity score threshold here), we just take the longest one with the assumption being that the longest one is most complete.

The default parameter here is 0.5. But let’s change it to something much higher and try to include every code snippet we can:

{
  "status_update_email": "johnson@contenda.co",
  "source_id": "youtube mozBidd58VQ",
  "type": "tutorial",
  "overrides": {
    "code_similarity_score_threshold": 0.99
  }
}

We are now using a cosine similarity score threhsold of 0.99 which means as long as the code snippets aren’t practically identical, it will be used. So now we’re passing every code snippet we’ve extracted from the video to GPT when generating a segment. The expected result would be that GPT includes more code snippets, some of which are redundant. Here’s a segment from the default parameters:

Now, we need to create a training function to train our model. We're going to implement
the training process within the standard Python if __name__ == " __main__": block.
We'll train our model for 10 epochs, looping through the dataset:
if __name__ == " __main__":
    # Train for 10 epochs
    for epoch in range(10):
        # Loop through the dataset
        for batch in dataset:
            # Training code goes here
Inside this loop, we'll include the necessary code to perform the forward pass, calculate
the loss, perform backpropagation, and update the model weights.

Now, here’s the same segment with the higher threshold:

To set up the training flow, we will use a standard Python function. First, include the
typical if __name__ == " __main__" statement to ensure the following code runs only
when this file is executed directly:
if __name__ == " __main__":
Next, create a loop to iterate through the epochs. In this example, we'll train the model
for 10 epochs:
if __name__ == " __main__":
    num_epochs = 10
    for epoch in range(num_epochs):
        # Training code goes here
Inside the loop, we'll iterate through the batches in our dataset:
if __name__ == " __main__":
    num_epochs = 10
    for epoch in range(num_epochs):
        for batch in dataset:
            # Batch processing code goes here
Now we're ready to write the training code for processing each batch.

As expected, GPT is more likely to use all the code snippets which means continuously explaining, rather than just give us the explanation at the end. We found this result to be unnecessary and made editing more tedious. But, if you’d prefer a step-by-step explanation, you should try bumping this threshold higher than 0.5. Or maybe you’d like to go the other way and cut down on code snippets even more, in which case you should try lowering this threshold.

Heading Prompts

Another prompt you can play with is our heading prompts! This is the prompt template we use to generate our headings:

Write a subheader for these paragraphs:

{TEXT}

Subheader:

And that’s it. We actually don’t use a system message for our headings. We found that GPT was honestly pretty satisfactory at this task just out of the box. But, if you want something more specific than what we have, you can easily add a system message to it:

{
  "status_update_email": "johnson@contenda.co",
  "source_id": "youtube mozBidd58VQ",
  "type": "tutorial",
  "overrides": {
    "heading_segment": {
      "system_message_string": "[INSERT EDITED SYSTEM MESSAGE HERE]"
    }
  }
}

Let’s say you prefer your headings to be much shorter. We can give GPT specific instructions in our system text like this:

When given text, you write a heading that contains 5 word or less that summarizes the 
main topics.

Now here’s a couple of the headings from our original blog:

Taking on the 15-Minute PyTorch Deep Learning Challenge

...

Setting Up the Python Environment and Building a Neural Network with PyTorch

...

Monitoring Training Progress and Saving the Model

And here’s what GPT turned them into:

15-Minute PyTorch Challenge

...

TorchVision Dependencies and Dataset

...

Monitoring Training Progress, Saving Model

It’s very good at listening to directions. As awkward as that last heading might seem, at least GPT was consistent in writing a headings in 5 words or less.

A common pattern also is if you want to give GPT instructions that are a bit more complex, it’s best to make it very explicit and to give at an example or two! Let’s say you want GPT to write your headings in a very specific format:

When given text, you write a heading that will always follow this format: 
'(overarching theme): (main topic)'.

Example headings:
Breaking into tech: Cassidy's journey as an enginer
Aquatic beasts: Why stingrays are so cool
Most beloved desserts: Why you should be drinking boba

This is what we get:

Code That series: Building a PyTorch deep learning model in 15 minutes

...

Building a neural network: Creating an image classifier with PyTorch

...

Deep learning with PyTorch: Setting up the neural network, optimizer, and training process

It really follows it to a tee. Now, do you want every heading to look like Heading 2: Electric Boogaloo? That’s a separate question, but at least now we know we can.

Max Input Segment

The parameter max_input_segment refers to how big our transcript segment chunks are allowed to be. We use different ways to find what we think are natural places to split up a transcript. We break up a transcript since most videos are long enough that it’s impossible to fit the whole transcript and have enough tokens to ask for a blog from GPT.

Our default max_input_segment is 1500 tokens. If you increase it any further, you might not see any changes. This is because the models we have in place are what determine where we would want our transcript to be segmented and this number merely determines what is too long of a segment, not what is too short. But, we will see some change if we decrease it, since we do have mechanisms in place to split up our segments even further. The API call would look like this:

{
  "status_update_email": "johnson@contenda.co",
  "source_id": "youtube mozBidd58VQ",
  "type": "tutorial",
  "overrides": {
    "max_input_segment": 200
  }
}

Our original blog has 21 segments. But, now with a much smaller max size for segments, we get 30 segments. Even from the introduction, we can see the change. The original blog’s 2 segments becomes 3 segments in the new blog.

Original:

In a recent attempt to challenge myself, I decided to code a PyTorch deep learning model in
just 15 minutes, despite having looked at the PyTorch documentation for the first time the
day before. This experiment was part of my "Code That" series, where I build projects
within a tight time frame.

For this task, I set some rules to make it even more challenging. The primary constraint
was the time limit of 15 minutes. Additionally, I wasn't allowed to look at any
documentation or pre-existing code, nor could I use CodePilot (though my subscription
had expired anyway). If I were to break any of these rules, a one-minute time penalty
would be deducted from my total time limit. The goal was to build a deep neural network

using PyTorch as quickly as possible under these conditions.

To raise the stakes for this challenge, I decided that if I failed to meet the 15-minute
time limit, I would give away a $50 Amazon gift card. In the last two episodes, I didn't
quite make the time limit, so I was eager to put in extra effort this time.

Before diving into the task, let's briefly discuss what PyTorch is. PyTorch is an
open-source deep learning framework mainly used with Python. Developed by the team at
Facebook, it accelerates the process of building deep learning models and is widely
used in cutting-edge models and deep learning research. Now that we have a basic
understanding of PyTorch, let's get started with the challenge!

New:

In a recent experiment, I dove into the PyTorch documentation for the first time and
attempted to code a deep learning model using PyTorch in just 15 minutes. This was
quite a challenge, considering the time constraint and the fact that it was my first
experience with PyTorch. The goal was to build a deep neural network as quickly as
possible, setting a strict time limit for the task. Stay tuned to find out how this
high-pressure coding session went and if the deep learning model was successfully

created within the allotted time.

As with previous challenges, the time limit for this task was set to 15 minutes. However,
there were some additional constraints to make the challenge more interesting. During this
coding session, I was not allowed to reference any documentation, pre-existing code, or use
CodePilot (though my subscription had already expired). If I were to break these rules and
use any existing resources, a one-minute penalty would be deducted from the total time
limit. With these constraints in place, the challenge was set to be a true test of my

coding skills and knowledge of PyTorch.

For this challenge, there were also stakes involved. If I failed to meet the 15-minute time
limit, I would be giving away a $50 Amazon gift card to one of you. Considering the results
from the last two episodes where the time limit wasn't reached, this attempt definitely
required extra effort.

Before diving into the coding session, let's briefly discuss what PyTorch is. PyTorch is
an open-source deep learning framework, primarily used with Python. Developed by the team
at Facebook, it significantly accelerates the process of building deep learning models.
PyTorch is widely used in cutting-edge models and deep learning research. With this
background information, we were ready to embark on the challenge.

Content wise, it’s about the same. But it does get lengthier when you have more segments. Our original blog comes out to around 3200 words. Our new blog comes out to around 3600 words. We prefer to keep our blogs a bit more concise, but definitely experiment with lowering the max_input_size if you want more content from GPT that you can edit down.

Completion Max Tokens

Lastly, we have completion_max_tokens. This refers to the amount of tokens we’re asking back from GPT. Now, this by itself will likely not change your blog a ton. But, I wanted to highlight it to guide your process of experimenting with our parameters. For the sake of the experiment, let’s set our completion_max_tokens really low:

{
  "status_update_email": "johnson@contenda.co",
  "source_id": "youtube mozBidd58VQ",
  "type": "tutorial",
  "overrides": {
    "body_segment": {
      "completion_max_tokens": 100
    },
    "body_code_segment": {
      "completion_max_tokens": 100
    }
  }
}

We’ll get blog segments back that look like this:

The 15-Minute PyTorch Deep Learning Model Challenge

In a recent episode of Code That, a challenge was taken up to code a PyTorch deep learning
model in just 15 minutes. This was attempted just a day after looking at the PyTorch
documentation for the first time. The rules of the challenge were simple but strict:

A time limit of 15 minutes.

No access to documentation or pre-existing code.

No use of CodePilot (though the subscription had expired anyway).

Breaking any of these rules would

You’ll notice that this blog segment ends mid-sentence. That’s because GPT wasn’t given enough tokens to finish saying what it wanted to. Limiting or increasing the amount of tokens GPT uses it for the return won’t change the return by itself. But, for example, if you start using a system template asking GPT to be lengthier in its return and you start getting segments like these, then you know that it’s time to increase your completion_max_tokens so that GPT can finish writing what you asked it to.

Share please 👉👈

And that’s a deeper dive into some of our parameters! Reminder, that this is still an experimental feature and not something we can currently provide a lot of support for. But we’re excited to see what you do with it!

Make something that you’re really happy with? Discover anything cool or hilarious? We’d love to hear from you! You can tweet us at @ContendaCo. And let us know if there’s anything else you’d like to tweak about the transformation process.

10x Code Snippets

Johnson Lin — Tue, 30 May 2023 00:00:00 +0000

If you’ve ever had to pause a video to copy a code snippet, then you know true pain. We love video tutorials as much as the next person, but sometimes we just want to copy/paste our way to the next step. That’s why we made an automatic code snippet detection model:

And we’re excited to announce that we’ve improved our original Alpha model and are releasing a new Beta model that has 10x’ed our previous model in more ways than one.

So how does it work?

When you submit a video to Contenda, one of the many fun things that happens is an OCR pipeline. In the simplest terms, imagine if each frame in a video went through this process:

What does the text on the screen say? Lemme write that down real quick.
Was that thing code? If yes, I bookmark this.
Comparing it to the blog, which pieces of code are the most relevant for understanding?
Insert those bad boys into the final blog output.

Comparing the Alpha and Beta results

We love when you try stuff and break it because that’s how we learn and improve! A common problem that was brought to our attention with Alpha was that it would sometimes talk around the code snippet without actually providing the code immediately afterwards.

Alpha:

In this section, we will add the opacity property to our animation and make some adjustments to the h3 element. Let’s begin by adding the opacity property:

Duplicate the existing keyframes and change the property to opacity.

Set the opacity value at 0% to 0 (no unit).

At 50%, set the opacity value to 0.2.

Finally, at 100%, set the opacity value to 1.

Now, let’s work on the h3 element…

With our new model, we’re able to much more consistently get the code snippet inserted after the explanation.

Beta:

In this tutorial, we’ll add opacity to our keyframe animation. First, we need to duplicate the keyframe for the “heading” animation and modify the opacity values. At the 0% mark, set the opacity to 0, which means the element will be completely transparent. Then, at the 50% mark, set the opacity to 0.2, making the element slightly visible. Finally, at the 100% mark, set the opacity to 1, making the element fully visible. Here’s the updated CSS code for the “heading” animation with the opacity changes:
@keyframes heading {
0% {
opacity: 0;
}
50% {
opacity: 0.2;
}
100% {
opacity: 1;
}
}
…

Our Beta model has more code snippets (though if I’m being honest, it’s not exactly 10x as much) while also having less redundant code! It also showed to be effective in decreasing hallucinations. And we will be continuously improving on the code snippet experience, so keep your eyes peeled for future updates and maybe, a potential 100X code snippet release.

That’s it!

This feature is LIVE both through the API and the frontend editor. If you’d like to learn more, please feel free to reach out to our team on Discord or sign up for our email list.

We can’t wait to see what you make!

Contenda Partners with NVIDIA

Johnson Lin — Tue, 23 May 2023 00:00:00 +0000

Contenda Joins NVIDIA Inception

We’re excited to announce that Contenda has joined NVIDIA Inception, a program that nurtures startups revolutionizing industries with technology advancements.

Contenda is a content catalyst for developer advocates to repurpose and extend existing videos into effective written content. Our API-first platform automates content creation workflows so teams can ship content faster. With built-in content quality checks, our generative AI models deliver finished drafts with high accuracy and tone matching.

NVIDIA Inception will allow Contenda to tackle the problem of hallucinations in generative AI and develop guardrails to create content users can trust. The program will also offer Contenda the opportunity to collaborate with industry-leading experts and other AI-driven organizations.

“Contenda focuses on delivering high quality, educational content to people who need it. I am excited for Contenda to help solve real-world problems in collaboration with NVIDIA.”

-Lilly Chen, CEO and Founder at Contenda

If you’d like to learn more, please feel free to reach out to our team on Discord or sign up for our email list.