Forem: Edmilson Silva

Ahhhh The trailer for Python: The Documentary is out

Edmilson Silva — Sun, 18 May 2025 16:28:32 +0000

I was reading some posts on Twitter when Python: The Documentary - Trailer appeared. I couldn't believe it and went straight to watch it. Now I'm really looking forward to watching it in full.

What did you think?

-Python: The Documentary - OFFICIAL TRAILER

Top 14 Best Vivaldi, Brave and Chrome Extensions in 2025

Edmilson Silva — Sun, 18 May 2025 16:23:02 +0000

arxiv-utils

Enhances ArXiv browsing by renaming tabs to paper titles, adding navigation buttons, and allowing PDF downloads with meaningful filenames.

🔗 arxiv-utils

Bitwarden Password Manager

Securely stores passwords, passkeys, and sensitive data across devices. Includes autofill, password generator, and encrypted vault.

🔗 Bitwarden Password Manager

Dark Reader

Enables dark mode on all websites. Reduces eye strain and improves readability, especially in low-light environments.

🔗 Dark Reader

Enhancer for YouTube

Customize YouTube with features like ad blocking, playback speed control, volume boost, themes, and keyboard shortcuts.

🔗 Enhancer for YouTube

GNOME Shell integration

Integrates Chrome with GNOME Shell for managing and installing GNOME extensions directly from the browser.

🔗 GNOME Shell integration

Google Keep Chrome Extension

Quickly save notes, links, and content to Google Keep with a single click from any webpage.

🔗 Google Keep Chrome Extension

Lighthouse

Open-source tool to audit performance, accessibility, SEO, and more for web pages and applications.

🔗 Lighthouse

Paperpile Extension

Manage academic papers: import, organize, annotate, and cite research directly in your browser.

🔗 Paperpile Extension

ProtonDB for Steam

Displays ProtonDB ratings on Steam to check Linux game compatibility before buying.

🔗 ProtonDB for Steam

Raindrop.io

All-in-one bookmark manager to organize, search, and sync web content across devices.

🔗 Raindrop.io

Save to Google Drive

Save web content, images, or screenshots directly to your Google Drive with ease.

🔗 Save to Google Drive

Unhook - Remove YouTube Recommended & Shorts

Removes YouTube distractions like recommended videos, Shorts, comments, and homepage suggestions.

🔗 Unhook

Video Color Enhancer

Adjust brightness, contrast, and saturation for videos to enhance visual experience.

🔗 Video Color Enhancer

Wappalyzer - Technology profiler

Detects technologies used on websites, including CMS, frameworks, analytics tools, and more.

🔗 Wappalyzer

Computer Vision I - Intro

Edmilson Silva — Sat, 12 Apr 2025 15:07:38 +0000

Introduction Computer Vision

Computer vision refers to a set of processes and techniques that allow a computer to have the ability to understand elements of the real world from digital images.

Preprocessing Images

According to Gonzalez and Woods (2018), there is no consensus among authors on where image processing ends and computer vision begins.

The terms refer to groups of necessary computational processes that require operations at different levels.

Low level:

Image preprocessing: Operation that will consist of cleaning unnecessary data within the image, validating dimensions and corrupted images, restructuring colors and other operations if necessary.

Medium Level:

Segmentation: Search for real-world objects, detecting shapes such as lines and curves

Classification: This is a technique that searches for characteristics within images to categorize each one with its due label.

High Level:

Essential step for inferring final results. Seeking to evaluate the classified objects.

Application Areas

Optical Character Recognition

As the name suggests, the game's functionality is to detect characters. It is widely used for images, PDFs, and others. For example, it can capture words and sentences in different types of files.

Medical image analysis

Used to detect tumors, organs, blood vessels and other possibilities

Autonomous vehicles

Vehicles that have the ability to detect objects in the real world, making decisions without the need for humans.

Object detection

Detect objects such as cars, people, signs, buildings and more.

Biometrics

Detect individual characteristics of each user to be used as identifiers.

Tracking

Track specific objects within an image.

Fundamentals of Digital Imaging

Workflow for Computer Vision Systems

Image collection

Most of the images found in the world are digital, these images are captured by sensors, sensors that have an energy input from a light source. This lighting includes visible light, x-rays, radars, infrared and ultrasound. Thus, the sensor output has a continuous voltage characteristic. In this way, it is possible to digitize the captured data to generate a response, in this case an image.

There are two situations within this:

Sampling: Obtaining a discrete and finite set of samples of the continuous data provided by the sensor in the form of a two-dimensional MxN matrix, defining a number of pixels in the matrix.

Quantization: Obtaining a discrete and finite set of intensity levels such as brightness for each pixel sample obtained from the continuous data provided by the sensor.

Digital Image

A digital image is a set of finite integers of pixels, with each pixel having an integer value that represents the level of intensity (brightness) of the pixel.

A digital image is defined with a function f(x, y):

x and y are integers that represent the spatial coordinates,
f is an integer that represents the level of intensity or brightness at each coordinate x, y

The digital image is represented by a matrix with M rows and N columns, where:

Visual Intensity
Numerical Intensity
The individual elements of each matrix are called pixels

import requests 
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np

data = requests.get('https://images.pexels.com/photos/31096175/pexels-photo-31096175/free-photo-of-black-and-white-aerial-view-of-busy-city-intersection.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=1').content 

f = open('1.jpg','wb') 
f.write(data) 
f.close()

data = requests.get('https://images.pexels.com/photos/19996987/pexels-photo-19996987/free-photo-of-brasil-game-show-2019.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=1').content 

f = open('2.jpg','wb') 
f.write(data) 
f.close()

data = requests.get('https://images.pexels.com/photos/15128096/pexels-photo-15128096/free-photo-of-red-bus-parked-beside-a-sidewalk.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=1').content 

f = open('3.jpg','wb') 
f.write(data) 
f.close()

Original Image

image = Image.open('/kaggle/working/1.jpg')
image_array = np.array(image)
plt.figure(figsize=(6, 6))
plt.imshow(image_array)
plt.axis("off")
plt.show()

Pixels with visual intensities

tile = image_array[0:25, 0:25, :]

print(f'Tile shape: {tile.shape}')

plt.figure(figsize=(6, 6))
plt.imshow(tile)
plt.axis("off")
plt.show()

Tile shape: (25, 25, 3)

Pixels with numerical intensities

fig, ax = plt.subplots(1, 4, figsize=(30, 7))

for i, channel in enumerate(['Red', 'Green', 'Blue', 'Grayscale']):
    if i < 3:
        ax[i].imshow(tile[:, :, i], cmap='gray')
        ax[i].set_title(f'{channel} Channel')
    else:
        grayscale = np.dot(tile[..., :3], [0.2989, 0.5870, 0.1140])
        ax[i].imshow(grayscale, cmap='gray')
        ax[i].set_title(f'{channel} Channel')

for i in range(25):
    for j in range(25):
        for k in range(3):
            ax[k].text(j, i, tile[i, j, k], ha='center', va='center', color='white', fontsize=6)
        ax[3].text(j, i, np.round(grayscale[i, j], 2), ha='center', va='center', color='white', fontsize=6)

for a in ax:
    a.axis('off')

plt.show()

Original Image

image = Image.open('/kaggle/working/2.jpg')
image_array = np.array(image)
plt.figure(figsize=(30, 7))
plt.imshow(image_array)
plt.axis("off")
plt.show()

Pixels with visual intensities

tile = image_array[0:25, 0:25, :]

print(f'Tile shape: {tile.shape}')

plt.figure(figsize=(6, 6))
plt.imshow(tile)
plt.axis("off")
plt.show()

Tile shape: (25, 25, 3)

Pixels with numerical intensities

fig, ax = plt.subplots(1, 4, figsize=(30, 7))

for i, channel in enumerate(['Red', 'Green', 'Blue', 'Grayscale']):
    if i < 3:
        ax[i].imshow(tile[:, :, i], cmap=f'{channel}s')
        ax[i].set_title(f'{channel} Channel')
    else:
        grayscale = np.dot(tile[..., :3], [0.2989, 0.5870, 0.1140])
        ax[i].imshow(grayscale, cmap='gray')
        ax[i].set_title(f'{channel} Channel')

for i in range(25):
    for j in range(25):
        for k in range(3):
            ax[k].text(j, i, tile[i, j, k], ha='center', va='center', color='white', fontsize=6)
        ax[3].text(j, i, np.round(grayscale[i, j], 2), ha='center', va='center', color='white', fontsize=6)

for a in ax:
    a.axis('off')

plt.show()

The number of intensity levels L of a digital image is a power of 2.

L = 2^k

where:

( L ) is the total number of possible intensity levels in the image.
( k ) is the number of bits used to represent each intensity level.

Intensity Range

Intensity levels are integers in the range ([0, L-1]).
This range is known as the intensity scale. It determines the minimum and maximum values that a pixel can assume in an image.

For example:

For ( L = 256 ) (( k = 8 ) bits), the intensity values range from ( 0 ) to ( 255 ).
In this case:
The value ( 0 ) represents the lowest intensity, associated with black.
The value ( 255 ) represents the highest intensity, associated with white. - All intermediate values correspond to different shades of gray.

Relationship Between Bits and Image Quality

The number of bits per pixel (( k )) is directly related to the quality and richness of detail in an image:

The higher the value of ( k ), the greater the number of intensity levels ( L ).
This allows the image to represent tonal variations more accurately, improving the visual perception of subtle details.

For example:

1 bit per pixel (( k = 1 )):
Only 2 intensity levels (( L = 2 )), representing black and white (binary image).
8 bits per pixel (( k = 8 )):
256 intensity levels (( L = 256 )), allowing richer gray tones.
16 bits per pixel (( k = 16 )):
65,536 intensity levels (( L = 65,536 )), used in high-definition or scientific images.

Neighborhood

The neighborhood of a pixel refers to the adjacent pixels (neighbors) of a central pixel in a given region of the image. This definition is fundamental for several operations in digital image processing.

Neighborhood Applications

The analysis of the neighborhood of a pixel is widely used in:

Spatial Filtering: For smoothing (removing noise) and enhancing images.
Image Segmentation: To divide the image into regions of interest based on characteristics such as color, texture or intensity.
Edge Detection: To locate edges and contours that define shapes and objects in an image.

Neighborhood Types

The number of pixels considered as neighbors is determined based on the area around the central pixel. The most common types include:

Neighborhood-4:
Includes the pixels directly above, below, to the left and to the right of the central pixel.
Total of 4 neighbors.

Neighborhood-8:
Includes the pixels of neighborhood-4 plus the pixels located diagonally in relation to the central pixel.
Total of 8 neighbors.

Introduction to Color in Computer Vision

Color as a Descriptor

Color is a useful descriptor for identifying and extracting features from objects in an image. Human vision perceives colors through combinations of primary colors of light, which are fundamental for visual representation in computational models.

Linear Color Spectrum

The linear color spectrum of visible light can be divided into six broad regions: violet, blue, green, yellow, orange, and red. Each region represents a range of distinct wavelengths within the visible spectrum.

Source: Wikimedia Commons

Primary Colors of Light

Primary colors of light are fundamental for the creation of other colors. These include:

R - Red
G - Green
B - Blue

Additive Model

The primary colors of light can be added together to produce secondary colors:

C - Cyan
M - Magenta
Y - Yellow

Mixing all three primary colors of light or a secondary with its opposite primary color at the correct intensities results in the production of white light.

Color Models

The two main color models or color spaces used in computer vision are:

RGB - Red, Green, Blue

In the RGB model, images are composed of three different pixel matrices:

R: intensity of the red color
G: intensity of the green color
B: intensity of the blue color

The combination of the intensity values of these three matrices results in the color image displayed on devices such as monitors.

image_path = '/kaggle/working/2.jpg'
image = Image.open(image_path)

image_array = np.array(image)

print(f'Image shape: {image_array.shape}')

fig, ax = plt.subplots(1, 4, figsize=(20, 5))

ax[0].imshow(image_array)
ax[0].set_title('Original Image')
ax[0].axis('off')

channels = ['Red', 'Green', 'Blue']
for i, channel in enumerate(channels):
    single_channel_image = np.zeros_like(image_array)
    single_channel_image[:, :, i] = image_array[:, :, i]
    ax[i + 1].imshow(single_channel_image)
    ax[i + 1].set_title(f'{channel} Channel')
    ax[i + 1].axis('off')

plt.show()

Image shape: (750, 1000, 3)

image_path = '/kaggle/working/3.jpg'
image = Image.open(image_path)

image_array = np.array(image)

print(f'Image shape: {image_array.shape}')

fig, ax = plt.subplots(1, 4, figsize=(20, 5))

ax[0].imshow(image_array)
ax[0].set_title('Original Image')
ax[0].axis('off')

channels = ['Red', 'Green', 'Blue']
for i, channel in enumerate(channels):
    single_channel_image = np.zeros_like(image_array)
    single_channel_image[:, :, i] = image_array[:, :, i]
    ax[i + 1].imshow(single_channel_image)
    ax[i + 1].set_title(f'{channel} Channel')
    ax[i + 1].axis('off')

plt.show()

Image shape: (750, 1125, 3)

HSV - Hue, Saturation, Value

In the HSV model, the characteristics used to differentiate one color from another are:

Hue: The dominant color perceived by the observer, representing the base color of the spectrum.
Saturation: The intensity or purity of the color, defined by the amount of white light mixed with a color.
- Pure colors from the continuous color spectrum are fully saturated.
- Colors like pink (red and white) and lilac (violet and white) are less saturated, meaning they have a lower intensity of color purity.
Value: The brightness or intensity of the color, ranging from lighter to darker shades.

import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
from matplotlib.colors import rgb_to_hsv

image_path = '/kaggle/working/2.jpg'
image = Image.open(image_path)

image_array = np.array(image)

print(f'Image shape: {image_array.shape}')

hsv_image = rgb_to_hsv(image_array / 255.0)

fig, ax = plt.subplots(1, 4, figsize=(20, 5))

ax[0].imshow(image_array)
ax[0].set_title('Original Image')
ax[0].axis('off')

channels = ['Hue', 'Saturation', 'Value']
for i, channel in enumerate(channels):
    ax[i + 1].imshow(hsv_image[:, :, i], cmap='gray')
    ax[i + 1].set_title(f'{channel} Channel')
    ax[i + 1].axis('off')

plt.show()

Image shape: (750, 1000, 3)

import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
from matplotlib.colors import rgb_to_hsv

image_path = '/kaggle/working/3.jpg'
image = Image.open(image_path)

image_array = np.array(image)

print(f'Image shape: {image_array.shape}')

hsv_image = rgb_to_hsv(image_array / 255.0)

fig, ax = plt.subplots(1, 4, figsize=(20, 5))

ax[0].imshow(image_array)
ax[0].set_title('Original Image')
ax[0].axis('off')

channels = ['Hue', 'Saturation', 'Value']
for i, channel in enumerate(channels):
    ax[i + 1].imshow(hsv_image[:, :, i], cmap='gray')
    ax[i + 1].set_title(f'{channel} Channel')
    ax[i + 1].axis('off')

plt.show()

Image shape: (750, 1125, 3)

References

Gonzalez, R. C., & Woods, R. E. (2008). Digital image processing (3rd ed.). Pearson Prentice Hall.

Author's notes

Thank you very much for reading this far. If you could like and share, I would be very grateful. If you didn't like it, I can't know if you liked the post. This way, you help me know where I should improve my posts. Thank you.

My Latest Posts

Edmilson Silva

Feb 29 '24

Did you say Free GPU?

#python #gpu #ai #machinelearning

Comments 1

5 min read

Edmilson Silva

Jan 6 '24

My Super Powers as a Software Developer - 2024

#tools #softwaredevelopment #workstations #productivity

Comments 4

11 min read

Edmilson Silva

Feb 12 '24

Becoming Efficient with Pomodoro

#tools #productivity #softwaredevelopment

Comments

10 min read

Favorites Projects Open Source

About the author:

Edmilson SilvaFollow

Machine learning, deep learning, and raw code. Presented clearly and with examples.

A little more about me...

Graduated in Bachelor of Information Systems, in college I had contact with different technologies. Along the way, I took the Artificial Intelligence course, where I had my first contact with machine learning and Python. From this it became my passion to learn about this area. Today I work with machine learning and deep learning developing communication software. Along the way, I created a blog where I create some posts about subjects that I am studying and share them to help other users.

I'm currently learning TensorFlow and Computer Vision

Curiosity: I love coffee

Free Books Python, Linux, Cloud and Programming - v2

Edmilson Silva — Sun, 09 Feb 2025 13:52:20 +0000

1. Linux and Shell Scripting

The Linux Command Line - A comprehensive guide to mastering the Linux command line.
Linux for Beginners - Introduction to fundamental Linux concepts and commands.
Linux Commands Handbook - Handy reference for common Linux commands.
Linux Kernel in a Nutshell - In-depth guide to understanding the Linux kernel.
Linux from Scratch - Build your own Linux system from scratch.
Bash Guide for Beginners - Beginner’s guide to Bash scripting.
The Korn Shell Manual - Programming manual for the Korn Shell.
Ten Steps to Linux Survival - A step-by-step guide to thriving in Linux environments.
Linux 101 Hacks - Practical hacks to master Linux basics.
Sams Teach Yourself Shell Programming - Quick course on shell programming.

2. Cloud Computing and DevOps

97 Things Every Cloud Engineer Should Know - Tips and best practices for cloud engineers.
Azure for Architects - Guide for architects designing Azure solutions.
Cloud Design Patterns - Patterns for building scalable cloud applications.
Generative AI on AWS - Guide to building generative AI models on AWS.
Migrating Applications to the Cloud - Effective strategies for cloud migration.
A Practical Guide to Cloud Migration - Best practices for migrating to the cloud.
CI/CD with Docker and Kubernetes - Learn CI/CD pipelines with Docker and Kubernetes.
The Modern DevOps Lifecycle - Mastering the full DevOps lifecycle.
Getting GitOps - Introduction to GitOps.
The Path to GitOps - Roadmap to adopting GitOps practices.
GitOps Cookbook - Practical recipes for managing applications with GitOps.

3. Programming and Software Development

Python

Think Python (v2) - Introduction to programming with Python.
Beyond the Basic Stuff with Python - Advanced Python techniques.
Automate the Boring Stuff with Python - Automating everyday tasks.
The Quick Python Book (4th Edition) - Practical Python learning.
Clean Code in Python - Writing clean and maintainable Python code.
Big Book of Small Python Projects - 81 fun Python projects.

Java and C++

Think Java - Beginner-friendly Java programming.
Effective Modern C++ - Best practices for modern C++.
Modern C++ Programming - Comprehensive guide to modern C++.
C++ Data Structures and Algorithms - An in-depth guide to C++ data structures.

4. Data Science and Analytics

Think Stats (v2) - Statistics and data analysis with Python.
Think Stats Online - Online version of Think Stats.
Think Bayes (2nd Edition) - Bayesian statistics in Python.
Data Science at the Command Line - Command-line tools for data science.
Python Data Science Handbook - Techniques and tools for data science with Python.
Hands-On Data Visualization - Practical guide to data visualization.
Learning Spark - Big data processing with Apache Spark.

5. Databases and Big Data

Kafka: The Definitive Guide - Understanding Apache Kafka.
Redis for Dummies - Introduction to Redis.
Graph Databases (Neo4j) - Leveraging graph databases.
Graph Algorithms - Algorithms for graph data.
SQL Cookbook (2nd Edition) - Tips and tricks for SQL.

Author's notes

My Latest Posts

Did you say Free GPU?

Edmilson Silva ・ Feb 29 '24

#python #gpu #ai #machinelearning

My Super Powers as a Software Developer - 2024

Edmilson Silva ・ Jan 6 '24

#tools #softwaredevelopment #workstations #productivity

Becoming Efficient with Pomodoro

Edmilson Silva ・ Feb 12 '24

#tools #productivity #softwaredevelopment

Favorites Projects Open Source

About the author:

Edmilson SilvaFollow

Machine learning, deep learning, and raw code. Presented clearly and with examples.

A little more about me...

I'm currently learning TensorFlow and Computer Vision

Curiosity: I love coffee

Free Books Python, Linux and Programming

Edmilson Silva — Fri, 24 Jan 2025 00:38:40 +0000

The Linux Command Line

The Linux Command Line

A comprehensive guide to mastering the Linux command line, from beginner to advanced.

Linux for Beginners

Linux for Beginners by Jason Cannon

A great starting point for those new to Linux, covering fundamental commands and concepts.

Linux Commands Handbook

Linux Commands Handbook

A handy reference for common Linux commands and their practical uses.

Linux Kernel in a Nutshell

Linux Kernel in a Nutshell

An in-depth guide to understanding the Linux kernel and its components.

Linux from Scratch

Linux from Scratch

Learn to build your own Linux system from the ground up.

Bash Guide for Beginners

Bash Guide for Beginners

A beginner's guide to learning Bash scripting on Linux.

The Korn Shell User and Programming Manual

Korn Shell Manual

A detailed manual for programming with the Korn shell.

Ten Steps to Linux Survival

Ten Steps to Linux Survival

A step-by-step guide to surviving and thriving in a Linux environment.

Linux 101 Hacks

Linux 101 Hacks

Practical hacks for mastering Linux basics and productivity.

Sams Teach Yourself Shell Programming in 24 Hours

Sams Teach Yourself Shell Programming

A quick course on shell programming with hands-on examples.

97 Things Every Cloud Engineer Should Know

97 Things Every Cloud Engineer Should Know

A collection of tips and best practices for cloud engineers.

Azure for Architects

Azure for Architects

A guide for designing cloud solutions on Azure for enterprise architects.

Cloud Design Patterns

Cloud Design Patterns

A reference for designing scalable and reliable cloud applications.

Generative AI on AWS

Generative AI on AWS

Learn about building generative AI models on AWS infrastructure.

Migrating Applications to the Cloud

Migrating Applications to the Cloud

A guide for migrating applications to the cloud effectively.

A Practical Guide to Cloud Migration

A Practical Guide to Cloud Migration

Best practices and strategies for cloud migration.

CI/CD with Docker and Kubernetes

CI/CD with Docker and Kubernetes

Learn how to implement CI/CD pipelines with Docker and Kubernetes.

The Modern DevOps Lifecycle

The Modern DevOps Lifecycle

A guide to mastering the full DevOps lifecycle using modern tools.

Getting GitOps

Getting GitOps

Learn how GitOps can streamline software delivery with Kubernetes.

The Path to GitOps

The Path to GitOps

A roadmap to adopting GitOps practices for infrastructure management.

GitOps Cookbook

GitOps Cookbook

Practical GitOps recipes for managing cloud-native applications.

Think Python (v2)

Think Python (v2)

An introduction to Python programming with a focus on concepts and problem-solving.

Think Java

Think Java

A beginner-friendly Java programming guide with exercises and examples.

Effective Modern C++

Effective Modern C++

A detailed book on mastering modern C++ features and best practices.

Speaking JavaScript

Speaking JavaScript

A comprehensive guide to learning JavaScript and its features.

Efficient R Programming

Efficient R Programming

Tips and techniques for writing efficient R code and improving performance.

Developing on AWS with C#

Developing on AWS with C#

A guide to using C# for cloud development on AWS.

Rust Atomics and Locks

Rust Atomics and Locks

A deep dive into concurrency in Rust with atomics and locks.

Ollama - Custom Model - llama3.2

Edmilson Silva — Mon, 18 Nov 2024 11:30:00 +0000

Import the ollama library.


import ollama

Create a class to configure custom models.

Methods:

init: Initializes the model with attributes such as name, system and temperature.
name_custom: Returns the custom name.
get_description: Creates the ModelFile structure.


class ModelFile:
    def __init__(self, model: str, name_custom: str, system: str, temp: float = 0.1) -> None:
        self.__model = model
        self.__name_custom = name_custom
        self.__system = system
        self.__temp = temp

    @property
    def name_custom(self):
        return self.__name_custom

    def get_description(self):
        return (
            f"FROM {self.__model}\n"
            f"SYSTEM {self.__system}\n"
            f"PARAMETER temperature {self.__temp}\n"
        )

Create a function to list all available models.
Output: Returns a list of models registered in ollama.


def ollama_list() -> None:
    response_ollama = ollama.list()
    return response_ollama['models']

Create a function to build a custom model based on the passed configuration.


def ollama_build(custom_config: ModelFile) -> None:
    ollama.create(
        model=custom_config.name_custom,
        modelfile=custom_config.get_description()
    )

Create a function to check if the custom model exists.


def check_custom_model(name_model) -> None:
    models = ollama_list()
    models_names = [model['name'] for model in models]
    if f'{name_model}:latest' in models_names:
        print('Exists')
    else:
        raise Exception('Model does not exists')

Create a function to generate a response based on the provided template and prompt.


def ollama_generate(name_model, prompt) -> None:
    response_ollama = ollama.generate(
        model=name_model,
        prompt=prompt
    )
    print(response_ollama['response'])

Create a function to delete a model by name.


def ollama_delete(name_model) -> None:
    ollama.delete(name_model)

Create a function to Order the steps of building, verifying and using the model.


def main(custom_config: ModelFile, prompt) -> None:
    ollama_build(custom_config)
    check_custom_model(custom_config.name_custom)
    ollama_generate(custom_config.name_custom, prompt)
    # ollama_delete(custom_config.name_custom)

Set the prompt and configure the Model File template.

Input:

Model: llama3.2
Custom name: xeroxvaldo_sharopildo
System: Smart anime assistant.

Output: Runs the main function to create the model, check for its existence, and generate a response to the prompt.


if __name__ == "__main__":
    prompt: str = 'Who is Naruto Uzumaki ?'
    MF: ModelFile = ModelFile(
        model='llama3.2',
        name_custom='xeroxvaldo_sharopildo',
        system='You are very smart assistant who knows everything about Anime',
    )
    main(MF, prompt)

output:

Naruto Uzumaki is the main protagonist of the popular Japanese manga and anime series "Naruto," created by Masashi Kishimoto. He is a young ninja from the Hidden Leaf Village, who dreams of becoming the Hokage, the leader of his village.

Naruto is known for his determination, bravery, and strong sense of justice. He is also famous for his unique ninja style, which involves using his Nine-Tails chakra (a powerful energy that he possesses) to enhance his physical abilities.

Throughout the series, Naruto faces numerous challenges and adversaries, including other ninjas from different villages, as well as powerful enemies like Akatsuki members and the Ten-Tails' jinchuriki. Despite facing many setbacks and failures, Naruto perseveres and grows stronger with each challenge he overcomes.

Naruto's character development is a central theme of the series, as he learns valuable lessons about friendship, sacrifice, and the true meaning of being a ninja. His relationships with his teammates, Sakura Haruno and Sasuke Uchiha, are particularly significant in shaping his personality and growth.

The Naruto series consists of two main arcs: the original "Naruto" arc (2002-2007) and the "Naruto Shippuden" arc (2007-2014). The latter is a continuation of the first arc, with Naruto now older and more powerful.

Overall, Naruto Uzumaki is an iconic anime character who has captured the hearts of millions worldwide. His inspiring story and memorable personality have made him one of the most beloved characters in anime history!


import ollama


class ModelFile:
    def __init__(self, model: str, name_custom: str, system: str, temp: float = 0.1) -> None:
        self.__model = model
        self.__name_custom = name_custom
        self.__system = system
        self.__temp = temp

    @property
    def name_custom(self):
        return self.__name_custom

    def get_description(self):
        return (
            f"FROM {self.__model}\n"
            f"SYSTEM {self.__system}\n"
            f"PARAMETER temperature {self.__temp}\n"
        )


def ollama_list() -> None:
    response_ollama = ollama.list()
    return response_ollama['models']

def ollama_build(custom_config: ModelFile) -> None:
    ollama.create(
        model=custom_config.name_custom,
        modelfile=custom_config.get_description()
    )


def check_custom_model(name_model) -> None:
    models = ollama_list()
    models_names = [model['name'] for model in models]
    if f'{name_model}:latest' in models_names:
        print('Exists')
    else:
        raise Exception('Model does not exists')

def ollama_generate(name_model, prompt) -> None:
    response_ollama = ollama.generate(
        model=name_model,
        prompt=prompt
    )
    print(response_ollama['response'])

def ollama_delete(name_model) -> None:
    ollama.delete(name_model)

def main(custom_config: ModelFile, prompt) -> None:
    ollama_build(custom_config)
    check_custom_model(custom_config.name_custom)
    ollama_generate(custom_config.name_custom, prompt)
    #ollama_delete(custom_config.name_custom)

if __name__ == "__main__":
    prompt: str = 'Who is Naruto Uzumaki ?'
    MF: ModelFile = ModelFile(
        model='llama3.2',
        name_custom='xeroxvaldo_sharopildo',
        system='You are very smart assistant who knows everything about Anime',
    )
    main(MF, prompt)

References

Author's notes

My Latest Posts

Did you say Free GPU?

Edmilson Silva ・ Feb 29 '24

#python #gpu #ai #machinelearning

My Super Powers as a Software Developer - 2024

Edmilson Silva ・ Jan 6 '24

#tools #softwaredevelopment #workstations #productivity

Becoming Efficient with Pomodoro

Edmilson Silva ・ Feb 12 '24

#tools #productivity #softwaredevelopment

Favorites Projects Open Source

About the author:

Edmilson SilvaFollow

Machine learning, deep learning, and raw code. Presented clearly and with examples.

A little more about me...

I'm currently learning TensorFlow and Computer Vision

Curiosity: I love coffee

In the future, will it be possible to have links on the Codeberg dev community profile or on Gitlab?

Edmilson Silva — Sun, 15 Sep 2024 12:39:43 +0000

Good evening everyone, I use other platforms besides Github. My question is whether in the future it will be possible to have links in the Dev Community profile other than Github, such as Codeberg and Gitlab.

This idea is to bring new people to the Dev Community and have other options to save projects, since not everyone uses Github.

Social network X (Twitter) was banned in Brazil and is it possible to have new links?

Edmilson Silva — Sun, 15 Sep 2024 12:36:17 +0000

X (Twitter) has been banned in Brazil. I can no longer access this social network. In new updates, will it be possible to add other social networks to the Dev Community profile, such as Mastodon and Reddit?

This would help a lot to keep in touch with followers and be able to publish new posts to the profile.

Partnership between Dev Community and Kaggle to help writers with their notebooks?

Edmilson Silva — Sun, 15 Sep 2024 12:35:07 +0000

I write posts on Dev Community. These posts are about the development of notebooks that I had on Kaggle and I write on this platform to share new information. However, I have to take cell by cell from the notebook to transfer it to the Dev Community post, and I imagine other writers do too. If there were a new update between Kaggle and Dev Community so that it would be possible to connect the Kaggle notebook to the Dev Community page, it would be a great help.

Because that would be great, many people don't read the notebooks on Kaggle and many people don't read the posts on Dev Community, which means you have to write twice. To reach both platforms. That way, you would create a notebook with all the content and share it in two places. That way, you attract the public in two different places.

Dev Community has a community essence that welcomes many people who are starting out, having motivational badges. Together with Kaggle, these achievements help the user to want to make more contributions. Being a two-way help for both the platform and the writer.

Statistics with R - Measures of Central Tendency and Measures of Dispersion

Edmilson Silva — Sat, 17 Aug 2024 13:50:25 +0000

mtcars

data(mtcars)
head(mtcars)

Loads and displays the first few rows of the mtcars dataset.

str(mtcars)

Displays the structure of the mtcars dataset, showing the type of each column.

summary(mtcars)

Measures of Central Tendency

Mean

\mu = \frac{1}{N} \sum_{i=1}^{N} x_i

Calculates the mean of a sequence of numbers.

n = c(1,2,4,5,6)

print(n)

mean_ = sum(n) / length(n)

print(mean_)

mean_cyl = sum(mtcars$cyl) / length(mtcars$cyl) 

print(mean_cyl)

Median

If ( N ) is odd:

\text{Med} = x_{\left(\frac{N+1}{2}\right)}

If ( N ) is even:

\text{Med} = \frac{x_{\left(\frac{N}{2}\right)} + x_{\left(\frac{N}{2} + 1\right)}}{2}

Calculates the median of a sequence of numbers with an odd size.

data_even <- c(7, 13, 19, 33, 67)

median_ <- median(data_even)
print(median_)

data_even <- c(7, 13, 19, 33, 67)
n = length(data_even)
median_ <- data_even[(n + 1) / 2]
print(median_)

Calculates the median of a sequence of numbers with an even size.

data_odd <- c(2, 34, 76, 92, 112)

median_ <- median(data_odd)
print(median_)

data_odd <- c(2, 34, 76, 92, 112)
n = length(data_odd)

median_ <- (data_odd[n / 2] + data_odd[n / 2 + 1]) / 2

print(median_)

median(mtcars$cyl)

median(mtcars$qsec)

Mode

\text{Mode} = \underset{x_i}{\operatorname{argmax}} \ f(x_i)

Creates a frequency table for a sequence of numbers.

numbers <- c(1, 233, 233, 010101, 342, 1, 2, 1111, 1, 55)

tnumbers <- table(numbers)
print(numbers)
print(tnumbers)

mode_ <- as.numeric(names(tnumbers)[tnumbers == max(tnumbers)])
print(mode_)

Identifies the most frequent value(s) in the sequence of numbers.

library(DescTools)

mode_ <- Mode(tnumbers)
print(mode_)

Measures of Dispersion

Defines a sequence of numbers.

n_arr = c(1,2,4,5,6)
print(n_arr)

Variance

\sigma^2 = \frac{1}{N} \sum_{i=1}^{N} (x_i - \mu)^2

Calculates the variance of a sequence of numbers.

mean_ <- mean(n_arr)

print('Mean')
print(mean_)

print('Variance')
var_ <- sum((n_arr - mean_)^2) / length(n_arr)

print((n_arr - mean_))
print((n_arr - mean_)^2)
print(sum((n_arr - mean_)^2))
print(length(n_arr))
print(var_)

Standard Deviation

\sigma = \sqrt{\sigma^2}

Calculates the standard deviation, which is the square root of the variance.

print('Variance')
var_ <- sum((n_arr - mean_)^2) / length(n_arr)
print((n_arr - mean_))
print((n_arr - mean_)^2)
print(sum((n_arr - mean_)^2))
print(length(n_arr))
print(var_)

print('Standard Deviation')
std_ <- sqrt(var_)
print(std_)

Calculates the standard deviation using the sd function in R.

std_ <- sd(n_arr)
print(std_)

Range

\text{Range} = x_{\text{max}} - x_{\text{min}}

Calculates the range, which is the difference between the maximum and minimum values.

range_ <- max(n_arr) - min(n_arr)
print('Range')
print(max(n_arr))
print(min(n_arr))
print(range_)

Calculates the range using the diff function.

range_ <- diff(range(n_arr))
print(range_)

Coefficient of Variation

\text{CV} = \frac{\sigma}{\mu}

Calculates the coefficient of variation, which is the ratio of the standard deviation to the mean.

mean_ <- mean(n_arr)
print('Mean')
print(mean_)

print('Variance')
var_ <- sum((n_arr - mean_)^2) / length(n_arr)
print((n_arr - mean_))
print((n_arr - mean_)^2)
print(sum((n_arr - mean_)^2))
print(length(n_arr))
print(var_)

print('Standard Deviation')
std_ <- sqrt(var_)
print(std_)

print('Coefficient of Variation')
cv <- std_ / mean_
print(cv)

My Latest Posts

Did you say Free GPU?

Edmilson Silva ・ Feb 29 '24

#python #gpu #ai #machinelearning

My Super Powers as a Software Developer - 2024

Edmilson Silva ・ Jan 6 '24

#tools #softwaredevelopment #workstations #productivity

Becoming Efficient with Pomodoro

Edmilson Silva ・ Feb 12 '24

#tools #productivity #softwaredevelopment

Favorites Projects Open Source

About the author:

Edmilson SilvaFollow

Machine learning, deep learning, and raw code. Presented clearly and with examples.

A little more about me...

I'm currently learning TensorFlow and Computer Vision

Curiosity: I love coffee

Statistics with R - Introduction to R Language and Statistics

Edmilson Silva — Sat, 17 Aug 2024 13:02:09 +0000

What is statistics?

Statistics is a science, where we use information from our world to provide answers to the questions created. But how is it science? Using statistics is not enough to just collect data (information), the data needs to be trained, understood and processed to obtain a final result. This entire process until reaching the result brings a learning of great value. Where at each point that you manipulate it can bring a different result. I don't think it's that bad, it can be a challenge, having to test and evaluate again until reaching an effective result.

Within statistics there are several visual, mathematical, data collection and software tools. To be able to address various real-world problems. The most incredible thing about statistics is that it is interdisciplinary. Every area that you think will have something statistical connected to it. Starting with the simplest thing, the TV news shows the weather forecast. The weather is constantly changing, but through data collection, there are already known patterns used to forecast the weather for the next day. Going further, understanding space, for example, supernovae, using what is already known to measure cosmic distances.

Why should we study statistics?

By learning statistics, we can understand the biggest problems in our world, where observation alone does not provide answers. By collecting and studying data, we can find more data that we cannot visualize without proper processing.

Why use the R language?

The R language is a programming language focused on statistics. It has a wide variety of algorithms and functions to apply to various statistical problems. It is possible to explore data sets, process data, visualize and more diverse resources available in its documentation. Furthermore, the project is open source, meaning that any human being can consult the code and assist in the development and evolution of the project.

R Project for Statistical Computing

Comments

Single-Line Comments in R

# Hey !!!!!

Multi-line Comments in R

# Hey !!!
# Hello !!!
# Here !!!!!!

Variables

Variable Assignment and Output

simple_text <- "Python or R ?"
[1] "Python or R ?"

Data Types

String Assignment and Structure

example_text <- "Python"
str(example_text)
[1] "Python"

Integer Assignment and Printing

number_dogs <- 15
number_cats <- 10

print(number_dogs)
[1] 15
print(number_cats)
[1] 10

Integer Structure

print(str(number_dogs))
int 15
print(str(number_cats))
int 10

Double Assignment and Structure

salary <- 1300.33
bonus <- 112.67

print(str(salary))
num 1300.33
print(str(bonus))
num 112.67

Class of Double

class(salary)
[1] "numeric"
class(bonus)
[1] "numeric"

Convert Double to Integer

to_int <- as.integer(bonus)
[1] 112

Rounding Numbers

round(bonus)
[1] 113
round(salary)
[1] 1300

Convert Double to Character

to_char <- as.character(salary)
[1] "1300.33"

Print Double and Character

print(salary)
[1] 1300.33
print(to_char)
[1] "1300.33"

Logical, Arithmetic, and Relational Operators

Multiplication

a <- 3
b <- 10

print(a * b)
[1] 30

Division

a <- 3
b <- 10

print(a / b)
[1] 0.3

Addition

a <- 3
b <- 10

print(a + b)
[1] 13

Subtraction

a <- 3
b <- 10

print(a - b)
[1] -7

Equality Check

"a" == "b"
[1] FALSE

Equality Check

1 == 1
[1] TRUE

Logical Class

logic_ <- TRUE

class(logic_)
[1] "logical"

Multiplication with Logical False

FALSE * 2
[1] 0
FALSE * 100
[1] 0
FALSE * 300
[1] 0

Multiplication with Logical True

TRUE * 2
[1] 2
TRUE * 100
[1] 100
TRUE * 300
[1] 300

Greater Than Check

2 > 5
[1] FALSE

Equality Check

2 == 5
[1] FALSE

Power Calculation

5^2
[1] 25

Vectors, Matrices, Dataframe

Create and Display Vector

group_numbers <- c(1,2,3,4,5,6,7,8,9,10)
[1] 1 2 3 4 5 6 7 8 9 10

Vector Multiplication

group_numbers * 5
[1]  5 10 15 20 25 30 35 40 45 50

Vector Power

group_numbers ^ 2
[1]   1   4   9  16  25  36  49  64  81 100

Vector Division

g <- group_numbers / 2
[1] 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

Class of Vector

class(g)
[1] "numeric"

Create and Display Vector with Integers

x <- c(133, 45, 23, 12, 1)
typeof(x)
[1] "double"
length(x)
[1] 5

Create and Display Mixed Type Vector

x <- c(33, 132.4, TRUE, "Python", FALSE)
[1] "33"     "132.4"  "TRUE"   "Python" "FALSE"
typeof(x)
[1] "character"

Create and Display Named Vector

x <- c("first_name"='Xeroxnildo', "last_name"='Carlomeu', "year"=97)
names(x)
[1] "first_name" "last_name"  "year"      
x["first_name"]
[1] "Xeroxnildo"
x["last_name"]
[1] "Carlomeu"
x["year"]
[1] "97"

Sequence with Increment

seq(1, 40, by=0.7)
[1]  1.0  1.7  2.4  3.1  3.8  4.5  5.2  5.9  6.6  7.3  8.0  8.7  9.4 10.1 10.8 11.5 12.2 12.9 13.6 14.3 15.0 15.7 16.4 17.1 17.8 18.5 19.2 19.9 20.6 21.3 22.0 22.7 23.4 24.1 24.8 25.5 26.2 26.9 27.6 28.3 29.0 29.7 30.4 31.1 31.8 32.5 33.2 33.9 34.6 35.3 36.0 36.7 37.4 38.1 38.8 39.5 40.2

Sequence with Length

seq(1, 10, length.out=6)
[1]  1.0  2.8  4.6  6.4  8.2 10.0

Decision and repetition structures

Variable Assignment and Printing

question <- 'Python is better than R ?'
print(question)
[1] "Python is better than R ?"

Simple If Statement

x <- TRUE
if(x){
   print("True")
}
[1] "True"

If-Else Statement

x <- -100
if(x > 0){
   print("TRUE")
} else {
   print("FALSE")
}
[1] "FALSE"

For Loop with Conditional Increment

x <- c(33,12,6,2,1,13,154)
count <- 0
for (val in x) {
    if(val %% 2 == 0)  count = count+1
}
print(count)
[1] 4

My Latest Posts

Did you say Free GPU?

Edmilson Silva ・ Feb 29 '24

#python #gpu #ai #machinelearning

My Super Powers as a Software Developer - 2024

Edmilson Silva ・ Jan 6 '24

#tools #softwaredevelopment #workstations #productivity

Becoming Efficient with Pomodoro

Edmilson Silva ・ Feb 12 '24

#tools #productivity #softwaredevelopment

Favorites Projects Open Source

About the author:

Edmilson SilvaFollow

Machine learning, deep learning, and raw code. Presented clearly and with examples.

A little more about me...

I'm currently learning TensorFlow and Computer Vision

Curiosity: I love coffee

AI Taxonomy

Edmilson Silva — Sat, 03 Aug 2024 00:59:13 +0000

With the great evolution of technology, several fields are advancing. One of these fields is Artificial Intelligence, and every time you search for it, something new is coming out of the oven. More and more new applications appear on the web, with some new feature that leaves you surprised. Applications that have the potential to solve everyday problems and help many people to complete complex tasks.

But do you know what the structure of Artificial Intelligence is like today? The taxonomy exists in a way that creates clarity for the various areas involved, making it easy to understand each step of its structure.

Layers of the Artificial Intelligence. Source: AI Taxonomy

Level 1 - Physical

The physical layer involves the entire group of physical elements that make up a system that is capable of mapping its connections through voltage, current and load, making it possible to map mathematical elements at a higher level of processing matrices, numbers and others. These are the physical elements, home computers, quantum computers, CPUs, GPUs, TPUs and so on.

Level 2 - Functional

The functional layer involves computational processing, dealing with areas of mathematics such as arithmetic, having the capacity for operations between numbers (addition, subtraction, multiplication, division). In addition, it involves algebra for processing sets, functions, topologies.

Level 3 - Computational

The computational layer involves real-world information to be processed, becoming computational data. Data that is analyzed, processed and standardized. In such a way that symbols and values are generated, to guide the destination of each piece of information. For better understanding, this data arrives raw and with a lot of noise, like a diamond extracted from a mine. From there, the data will be polished to become data that aggregates information of the best quality.

Level 4 - Semantic

The semantic layer plays the main role where reasoning and symbolic translation for human understanding occur. This layer has solutions for data manipulation and independently creating your own actions, but it must follow rules to generate symbols so that they can be understood.

Level 5 - Agency

In this layer, I even bring up a well-known phrase where magic happens. When we go through all the previous layers and reach this layer, we can visualize the results of all the processes, making it possible to make decisions autonomously, where you must remember which environment was developed for so that it is possible to take advantage of all the previous layers and have better performance. It is possible to perform your own actions.

References

[1] T. Prodromakis and A. Serb, "AI Taxonomy," University of Southampton, [Online]. Available: AI Taxonomy," University of Southampton.
[2] S. S. Gill, M. Golec, J. Hu, M. Xu, J. Du, H. Wu, G. K. Walia, S. S. Murugesan, B. Ali, M. Kumar, K. Ye, P. Verma, S. Kumar, F. Cuadrado, and S. Uhlig, "Edge AI: A Taxonomy, Systematic Review and Future Directions," [Online]. Available: Edge AI: A Taxonomy, Systematic Review and Future Directions.