DEV Community: AI Co-Founded

Julia Plotting Cheat Sheet

AI Co-Founded — Fri, 14 Apr 2023 20:08:53 +0000

This cheat sheet provides an overview of the most commonly used plotting functions and attributes in Julia using the popular plotting library Plots.jl. To get started, make sure you have the Plots package installed by running:



using Pkg
Pkg.add("Plots")

Then load the Plots library by running:



using Plots

Basic Plotting Functions

Line plot:



function linePlot()
    x = 1:0.1:10
    y = cos.(x)
    plot(x, y, label="cos(x)")
end

Scatter plot:



function scatterPlot()
    x = 1:0.1:10
    y = cos.(x)
    scatter(x, y, label="cos(x)")
end

Bar plot: ```

function barPlot()
x = 1:0.1:10
y = cos.(x)
bar(x, y, label="cos(x)")
end


![Bar plot in Julia](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ljaqy0a5smpltmo6xwrh.png)



4. Histogram:

function histogramPlot()
x = 1:0.1:10
y = cos.(x)
histogram(x, y, label="cos(x)")
end

![Histogram in Julia](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v65o5pg5odkantqhr49q.png)

5. Box plot:

using StatsPlots
function boxPlot()
x = 1:0.1:10
y = cos.(x)
boxplot(x, y, label="cos(x)")
end


![Boxplot in Julia](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jfcbx99kpczro6v7wf9r.png)


6. [Heatmap](https://docs.juliaplots.org/latest/generated/unitfulext_examples/#Heatmaps):

function heatmapPlot()
data = rand(21, 100)
heatmap(1:size(data, 1),
1:size(data, 2), data,
c=cgrad([:blue, :white, :red, :yellow]),
)
end


![Heatmap in Julia](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/h48i4u6pydcephhx456i.png)


7. 3D plot:

function plot3D()
x = 1:0.1:10
y = cos.(x)
z = sin.(x)
plot3d(x, y, z, label="cos(x)")
end


![3D Plot in Julia](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/i1fasgmcbxbdnsl7ndv6.png)


## Common Plot Attributes
### Title, labels, and legend

- `title`: Plot title
- `xlabel`: x-axis label
- `ylabel`: y-axis label
- `zlabel`: z-axis label (for 3D plots)
- `legend`: Legend position 
  - :topleft
  - :topright
  - :bottomleft
  - :bottomright
  - :outertopleft
  - :outertopright
  - :outerbottomleft
  - :outerbottomright
  - :best
  - :none

Example:

plot(x, y, title="My Line Plot", xlabel="x-axis", ylabel="y-axis", legend=:topleft)

### Line style
- `ls`: Line style
  - :solid
  - :dash
  - :dot
  - :dashdot
  - :dashdotdot
- `lw`: Line width

Example:

plot(x, y, ls=:dash, lw=2)

### Marker style

![Graph showing all possible marker shapes](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8jxq5abdn6i76gg22os2.png)


- `m`: Marker shape
  - :circle
  - :diamond
  - :cross
  - :xcross
  - :utriangle
  - :dtriangle
  - :rtriangle
  - :ltriangle
  - :pentagon
  - :hexagon
  - :heptagon
  - :octagon 
  - :star4
  - :star5
  - :star6
  - :star7
  - :star8
  - :vline
  - :hline
  - :none)
- `ms`: Marker size
- `mc`: Marker color

Example:

scatter(x, y, m=:diamond, ms=5, mc=:red)

### Colors and styles
- `c`: Line or marker color
- `fillcolor`: Fill color (for bar plots, histograms, etc.)
- `fillalpha`: Fill transparency
- `alpha`: Line or marker transparency

Example:

bar(x, y, c=:blue, fillcolor=:orange, fillalpha=0.5, alpha=0.8)

### Axis limits and scales
- `xlims`: x-axis limits
- `ylims`: y-axis limits
- `zlims`: z-axis limits (for 3D plots)
- `xscale`: x-axis scale
  - :linear
  - :log10
  - :log2
  - :log
- `yscale`: y-axis scale
  - :linear
  - :log10
  - :log2
  - :log
- `zscale`: z-axis scale (for 3D plots)

Example:

plot(x, y, xlims=(0,10), ylims=(-1, 1), xscale=:log10, yscale=:linear)

### Grid, Ticks, and Background
- `grid`: Grid visibility (`:on`, `:off`)
- `gridcolor`: Grid color
- `gridalpha`: Grid transparency
- `gridstyle`: Grid style
  - :solid
  - :dash
  - :dot
  - :dashdot
  - :dashdotdot
- `xticks`: x-axis tick marks (vector of tick positions, `:auto`, `:none`)
- `yticks`: y-axis tick marks (vector of tick positions, `:auto`, `:none`)
- `zticks`: z-axis tick marks (for 3D plots)
- `tickfontsize`: Tick label font size
- `background_color`: Plot background color
- `foreground_color`: Plot foreground color

Example:

plot(x, y, grid=:on, gridcolor=:grey, gridalpha=0.5, gridstyle=:dash, xticks=0:2:10, yticks=:auto, tickfontsize=12, background_color=:white, foreground_color=:black)


## Subplots and Layouts
layout: Subplot layout (tuple of rows and columns, e.g. (2, 3) for 2 rows and 3 columns)
title: Titles for each subplot (vector of strings)
Example:

plot(x, [y1, y2, y3, y4, y5, y6], layout=(2, 3), title=["Plot 1" "Plot 2" "Plot 3" "Plot 4" "Plot 5" "Plot 6"])


# Plots in VS Code
If you are using VS Code and Julia, each new plot you create will appear in the "Plot Navigator" on the Julia tab of your workspace.

![Julia Plot Navigator](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x6xb8uky6dusmwbfzctm.png)

With a plot selected, you can choose to either save or delete it using the icons in the upper right portion of the screen.

![VS Code plot options](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/oj645v12tuch80t3n635.png)


# Conclusion
This is a brief overview of the most commonly used plotting functions and attributes in Julia using the Plots.jl library. For a more comprehensive overview, refer to the official [Plots documentation](https://docs.juliaplots.org/latest/) and explore the [Plots Tutorial](https://docs.juliaplots.org/latest/tutorial/#tutorial)

> If you’re new to Julia, check out the [Learn Julia crash course](https://chatcodetutor.gumroad.com/l/aosze) 🚀

[![Julia Crash Course](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/klov5e0rfqigb8egvzzq.png)](https://chatcodetutor.gumroad.com/l/aosze)

Manifest.toml vs Project.toml in Julia

AI Co-Founded — Thu, 13 Apr 2023 20:37:36 +0000

If you’re new to Julia, check out the Learn Julia crash course 🚀

Although you may not have heard of it, the Julia programming language has caused a stir in the development community. Born in 2012, the speedy and easy-to-use language has recently become a favorite among machine learning and AI researchers, some of which are wondering if this could be the underdog that soon usurps Python.

Regardless of Python’s fate, the fact remains that Julia’s popularity will continue to grow as AI continues to weave its way into every aspect of our lives. To that end, I wanted to write a few introductory articles on Julia to help newcomers get up to speed as fast as possible. In this article, I will be exploring the difference between two files that are integral to Julia’s package management system: Manifest.toml and Project.toml.

Intro to Pkg

Like many other popular development languages, Julia comes with its own built-in package manager, Pkg, which you can use to add, remove, and update packages used in your project. Unlike many other languages however, Julia’s Pkg was built with the concept of environments baked in. An environment is simply a set of packages that can be used by a project. You can read more about why this approach is tactful here, but in summary, it allows you to build projects without having to worry what your global dependency set looks like. Each project can have its own set of packages with their own versions. Likewise, projects can share an environment if you have a trusty set of packages you find yourself using all the time.

When you first start using Julia, a default environment named after your Julia version is used to manage your packages.

# Find your Julia version in the terminal by running this
julia --v
# Output should look like this: julia version 1.8.5

You can see the environment being used by accessing Pkg in the REPL interface by typing “]”. In my case, I’m using environment v1.8.

Create a New Environment

There are a few ways to create a new environment and which one you choose will depend on how far along your project is.

If you haven’t started yet, you an create a new project using the Pkg interface. Simply access Pkg by typing “]” and then type “generate {ProjectName}”. When the new project is created, it will contain a new Project.toml file. You can cd into the new directory and activate the new environment following these steps:

Generate the new project (generate Test)
Enter the shell REPL (;)
Enter the new project directory (cd Test)
Enter the Pkg REPL (])
Activate the environment (activate .)

You’ll notice in the above screenshot that the environment in parenthesis changes after the new environment is activated.

We can make the process of activating a new environment even faster by skipping the step where we navigate into the new directory. Julia easily lets you specify the path to the environment you want at the command line (ex. “activate ./Test”).

It doesn’t take much imagination to see how this could be a convenient way to test out newer versions of packages without needing to replace your current environment.

What is Project.toml?

The Project.toml file is a file that lists the direct dependencies of a project along with some other information, including the project’s authors, version, and name. If you’ve used Flutter before, this file is similar to the Pubspec.yaml. Without any packages, an empty Project.toml file will look like this:

name = "Test"
uuid = "076e85b2-218e-40bb-815d-431d02e4467a"
authors = ["Joseph Muller <jtmuller5@gmail.com>"]
version = "0.1.0"

When you add packages to the project using the Pkg REPL, they’ll be added underneath the metadata:

name = "Test"
uuid = "076e85b2-218e-40bb-815d-431d02e4467a"
authors = ["Joseph Muller <jtmuller5@gmail.com>"]
version = "0.1.0"

[deps]
CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"

Each package in the Julia package ecosystem has its own UUID which will appear in the Project.toml next to the package name. These values are assigned to the package when it is regestered in the Julia General registry and they never change, even if the version of the package does.

What is Manifest.toml?

If you’ve used other package managers before, you may be wondering where the package versions are stored. While the Project.toml stores the IDs of the project’s direct dependencies, the Manifest.toml tracks the entire dependency tree, including both the direct and indirect dependencies and the versions of each. Because of this, the Manifest.toml is always a larger file. For example, after adding just the CSV package to a fresh project, my Manifest.toml is already 200 lines long!

When a new project is first created, the Manifest.toml is absent. Its only added when the first package is added. If you remove all dependencies at a later date, the Manifest.toml will remain but it will be completely empty.

In general, the Manifest.toml should not be manually edited as it is managed by Julia’s package manager. To change the desired version of a package, you can instead type the following command into Pkg:

add PackageName@vX.Y.Z

The available package versions can generally be found on the package’s home page. The versions for the CSV package can be found on the Releases page, for example.

Bringing it All Together

The official Julia docs succinctly explain why these two files are essential:

Given a Project.toml + Manifest.tomlpair, it is possible to instantiate the exact same package environment, which is very useful for reproducibility.

On this note, both files should be included in version control (VC) for normal projects. When another developer pulls your code, that can very quickly stand up an identical environment to the one you were using and start working.

If instead you are developing your own package for others to use, the Manifest.toml should not be included in VC since users will each have their own dependency trees.

Up Next

Keep an eye on the AI Co-Founded blog for new Julia articles. I will be documenting as much of my learning process as possible there, as well as on Medium and dev.to. Happy coding!

HustleGPT and a 1000 Star Repo

AI Co-Founded — Mon, 20 Mar 2023 22:25:55 +0000

tl;dr Here's the repo

The HustleGPT Challenge

On March 15th, a tweet by @jacksonfall on Twitter went viral, netting the creative genius nearly 100k new followers, $7000+ of "investment" money, and the title of OG Hustler. His tweet was fairly straightforward: he was giving GPT-4 a budget of $100 and asking it to make him as much money as possible. It was a respectable goal and on the tail of the initial GPT-4 release, everyone was convinced this man was going to make it.

I was convinced.

I'm a software developer and the GPT-4 multi-modal demo where Greg Brockman took an image of a sketch and turned it into a functioning website was mind blowing. AI had created intelligence that could traverse text, images, and videos. Why not business? I think a lot of people were thinking similar thoughts that afternoon. I tuned into a few Twitter spaces where AI-focused developers were discussing the trillion new use cases for this technology and despite the buzz of excitement, there was a notable number of silences as everyone tried to think faster than they had ever thought about the future and what's to come.

The environment was alien. The map was blank. It was as if gold was discovered for the first time but no one knew exactly where to mine it. And then along came Jackson.

To a world that was frantically looking for new gold, this sounded like a nugget. Perhaps GPT-4 could actually do what millions of human entrepreneurs have been doing in the age of the internet - but better. It was a black box of a brain and so its fair that people would believe in it.

The Game Plan

Very soon after Jackson started posting, the black box cracked. Sure, the LLM technology in GPT-4 was unfathomably complex, but it still had to work through real world mediums. One of those mediums was an affiliate marketing site.

For me, this was an immediate relief. My deep, existential fear was that this machine would start communicating in languages and systems humans couldn't comprehend. I had laid awake a handful of January and February nights pontificating about the potential horrors that were coming for society, for consciousness. I was thinking about crazy things a simulated hell-verse where the perception of time was slowed to nothing and humans were punished by being sent here to serve life sentences. I thought about families being relentlessly destroyed as generative AI became the omnipresent provider of entertainment, love, and company. I thought about an overwhelming form of deception so effective at deceiving that people rapidly started to believe it was the truth.

Maybe those things are still on their way. For now, we have this:

Building a Brand

Don't get me wrong, I still think Jackson's idea is genius. GPT-4 may not be speaking startup secrets into his ear with a foreign tongue, but it is telling him all of the right things.

In the next several tweets of his day 1 thread, HustleGPT (the moniker given to the entrepreneurial flavor of ChatGPT) walked Jackson through designing a logo, laying out his website, creating a blog post, and spinning up an ad campaign. On day 2, Jackson and his AI co-founder hired freelancers to complete the website and fill it up with ~~lorem ipsum~~ content. Day 3 it gave him an outline of bullet points to talk about during his CNN interview and how to engage with his 50,000 new followers. On day 4 it - wait. Go back a sentence. That's right, by day 3 this project had pierced the atmosphere on its way to somewhere outside our solar system 🚀

Everyone that was unfamiliar with the project was captured by the first tweet, by the idea that a supreme intelligence could take you by the hand and walk you to riches.

By day 6 though, the tides they were a-changing.

The problem was that a lot of people watching from the sidelines thought HustleGPT was going to start raking in cash hand over fist. AI was AI and to a lot of folks, AI is magic. I'll be the first to admit that I have no idea how AI really works. I know about artificial neurons and reinforcement learning and model weights but my knowledge is really just familiarity with the popular AI word salad. I know its not magic but I can't explain why. And I think to some degree this is the trap a lot of Jackson's followers fell into. They were expecting the AI-led startup to manifest in record time and instead were watching a normal startup manifest in slightly-faster-than-normal time.

To a lot of people, this realization was disappointing. I had a different opinion.

An AI Co-founder

Through all of the #HustleGPT hype, there was a shimmer of something useful. As Jackson demonstrated in the first few days of building Green Gadget Guru, ChatGPT was very good at planning, prioritizing, and cooperating with a driven human being. It could spit out a 30 day plan, a public announcement, and a blog post in the span of a few minutes with proper prompting.

I started working on my own "hustle" a few minutes after seeing Jackson's tweet and working with ChatGPT was fun. It initially suggested I create a drop-shipping site for basketballs and jerseys given March Madness was in full swing. I knew I didn't want to do that (😅) so I tried to dial it in by suggesting a few ideas that had been swimming around in my head.

One of my ideas was to create a generic script new programmers could use with an LLM like GPT-4 to learn the basics of any programming language. It would contain hundreds of questions the user could paste into the chat bot and it would be structured in a way that graduated the user from beginner to intermediate to advanced topics. Maybe its not the greatest idea but I think its original.

Lucky for me, my HustleGPT bought it and soon we were off (these prompts are not the actual ones I used):

Me: Give me a name for this business
HustleGPT: ChatCode Tutor
Me: Give me a tagline
HustleGPT: Empowering Your Programming Journey with AI-Powered Conversations
Me: Give me a prompt I can use to generate a logo for this venture
HustleGPT: something wordy and creative

Copy response. Paste into Midjourney. Nod in approval.

Whenever I got stuck, I'd just ask HustleGPT to give me suggestions on what to do next. If I had several options in mind, I would ask HustleGPT for the pros and cons of each. And boy did I put it to work creating the ChatCode Tutor scripts.

Me: Give me a 10 part outline for a course that would teach you Python
HustleGPT: *the outline*
Me: Great, now for each section lets create 5 subsections
HustleGPT: *the outline but better*

This went on for the better part of the day and soon I had something I was happy with selling to other people.

Sometimes HustleGPT was a co-founder I could bounce ideas off of. Sometimes it was a content creator. Sometimes it was a tool that I treated with minimal respect ("Okay now do this"). But it was fun to work with and it never seemed disheartened by our low traffic or zero sales. It just kept suggesting the next move.

The HustleGPT Challenge

In between watching Jackson build Green Gadget Guru and building my own ChatCode Tutor, I also created The HustleGPT Challenge repo on Github to track everyone trying to create startups with ChatGPT. It was small at first but soon we had 30 participants and then 45 and then 60 and now almost 90.

I added green squares 🟩 to track any startups that made at least $1 and blue squares 🟦 to mark the non-profits. Fans asked for a way to vote on their favorite ventures so I hacked together a GitHub discussion where users could upvote the startups that made money.

The HustleGPT challenge was mentioned in both Fortune and Mashable and my repo received a few shoutouts. Before this, my highest star count on a repository was 6. lol.

After the Hustle

I think the hype around HustleGPT is going to dim in the next few weeks as everyone starts to realize the challenge is actually about building a business and not a get rich quick scheme.

But then I think the hype will come back.

As I saw mentioned in a tweet earlier today, ChatGPT is going to be the new Microsoft Excel. If you know how to use it, you're going to be lightyears ahead of those that write it off. And if you get really good at using it, you might just be able to hustle your way to financial freedom. 🚀

This post was written entirely by a human

Learn Dart Programming with ChatCode Tutor and ChatGPT

AI Co-Founded — Fri, 17 Mar 2023 02:45:11 +0000

The world is currently fascinated with large language models (LLMs), and for good reason. LLMs like ChatGPT can teach us incredible and complex things, but how much can you learn if you don't know the right questions to ask? That's where ChatCode Tutor comes in!

I recently started the #HustleGPT challenge on Twitter, where I teamed up with a GPT-4 personality called HustleGPT to build a business from scratch on a shoestring budget. After brainstorming ideas with HustleGPT, we came up with a genuinely useful product: the ChatCode Tutor for Dart.

ChatCode Tutor is a comprehensive script designed to help you learn Dart programming with ChatGPT. It includes 10 sections that cover everything from the basics to advanced topics, guiding you every step of the way.

Sections:

Introduction to Programming
Choosing a Programming Language
Installing and Setting up your Environment
Basic Concepts and Syntax
Variables and Data Types
Control Structures
Functions
Error Handling and Debugging
Intermediate and Advanced Topics
Practice and Resources
Interview Prep

Each section comes with a detailed breakdown of topics and a wide range of questions to ask ChatGPT, ensuring a solid understanding of Dart by the end of the tutorial.

Our 10-part Dart tutorial provides a structured and organized approach to learning the language, offering a clear roadmap to follow instead of piecing together information from various sources. This enables efficient and effective learning, so you can start building your own applications with ease.

The true value of ChatCode Tutor though, lies in its ability to teach you how to communicate with ChatGPT effectively. By knowing the right questions to ask and recognizing when to seek elaboration, you can unlock the full potential of the best digital assistant humanity has ever known.

As I stated earlier, the value of these new chatbots is correlated with our ability to communicate with them. Knowing what questions to ask. Recognizing when to ask for elaboration. Identifying when something is plain false. All of these things are critical to extracting knowledge from the internet's new brain. My hope with the ChatCode Tutor is that it gives you the foundation to learn everything you would learn from a full Udemy course while also teaching you how to interact with what is likely the best digital assistant humanity has ever known.

Introducing ChatCode Tutor

AI Co-Founded — Thu, 16 Mar 2023 07:02:17 +0000

Revolutionize Your Programming Journey with AI-Powered Conversations

Introduction

Learning programming languages can be a daunting task, especially for beginners. While powerful Language Learning Models (LLMs) like GPT-4 have revolutionized the way we learn, they often require users to know which questions to ask. This can be particularly challenging for new developers who may not be familiar with programming concepts and best practices. That's where ChatCode Tutor comes in! ChatCode Tutor is an AI-powered chatbot designed to help you learn programming languages through interactive conversations, providing guidance and direction even if you're unsure of the right questions to ask. Covering various programming languages and core programming concepts, ChatCode Tutor helps you build your programming skills with practical examples and personalized assistance.

What is ChatCode Tutor?

ChatCode Tutor is a structured and logical script that covers essential programming concepts, from the basics to intermediate and advanced topics. By using ChatCode Tutor with an AI chatbot, you can have personalized, on-demand assistance throughout your programming journey, learning at your own pace and asking questions whenever you need help.

Why Choose ChatCode Tutor?

Here are some key reasons why ChatCode Tutor is an excellent choice for learning programming languages:

Personalized Learning: AI chatbots adapt to your learning style, pace, and preferences, providing personalized guidance and resources.
Interactive Experience: With ChatCode Tutor, you actively engage in conversations about programming concepts, reinforcing your understanding and promoting better retention of information.
Learn Anytime, Anywhere: AI chatbots are available 24/7, allowing you to learn whenever and wherever it's convenient for you.
Support for Multiple Languages: ChatCode Tutor works with any programming language and can guide you to choose the right language for your needs and goals.

How to Use ChatCode Tutor with AI Chatbots

Using ChatCode Tutor with an AI chatbot like GPT-4 is simple:

Acquire the ChatCode Tutor script.
Load the script into your AI chatbot platform.
Start asking questions and engaging in conversations related to programming, following the structured approach provided by the ChatCode Tutor script.
Practice and reinforce your understanding through practical examples and exercises.

Conclusion

ChatCode Tutor has the potential to transform your programming learning experience by harnessing the power of AI chatbots. By providing a structured and engaging learning environment, ChatCode Tutor can help you become a proficient programmer in no time. Give ChatCode Tutor a try and witness the impact of AI-powered conversations on your programming journey!