Selfbook is setting a new standard for hotels to simplify, verify, and unify the direct booking experience

Selfbook

In Which Come Tidings of Great Moment to All Pallisers

Please don’t be insufferable and romanticize writing. Writing is easy! For most writers all it takes is to sit in a chair for 20 years staring at a blank screen until someone finally pays you. For you, however, I’d like to offer a few quick tips on how to write your own book quickly and painlessly. Ready? Duh. Also make sure the idea is interesting to someone besides you. If you’re going to write a space opera about robots and men who work together to defeat the evil Dorth Vorder or if you want to write a book about how to hack your life so you only work 2 hours a year then just stop right now. Ask your friends what they want to read and work through a few ideas before you hit on the perfect one. Or don’t and just write blind and hope that someone else cares about how CrossFit changed your life. Have an idea. . You cannot go on a journey unless you have a map. Anyone who tells you otherwise is lying to you. You must outline all of your chapters, be it a non-fiction or fiction book. You don’t have to know exactly what each chapter will contain, but you do have to have a general path. Below is an “outline” for a novel I’m working on. I use an app called which lets your create books in a very unique way. Before you whine about how you don’t want to learn another program please shut up for a minute. Outline Scrivener Take a look at this. This is a novel. There is a main “Manuscript” folder that holds little subfolders. Those are the chapters. The subfolders in this image have little flags on them. This probably confuses you. Don’t worry. Those little flags I added myself by right clicking and changing the icon. I know that if I showed you these flags you would be confused so now I need to explain them. You can make chapters look like almost anything: I used flags to identify who the main characters were in each chapter. This is helpful if you’re a visual learner or you like icons. Inside those chapter folders are scenes. Each scene is a text file. If you click on the chapter folder you’ll see a little notecard representation of the scenes inside. Guess what that means? You can create a chapter folder, call it “Welcome To My Amazing Brain,” and add a scene that says “Introduce my brain to the reader.” Do that many times and you’ll have a book. Most books should be about 50,000 words so you’ll want 12–15 chapters total with a few thousand words per chapter. Prepare for this in advance and you won’t write a 500,000 word opus nobody wants to read nor will you write a pamphlet. Scrivener lets you drag chapters and scenes around and finally compile your book into an ebook format. Buy the software. It’s really good. Can you outline on paper in a beautiful Moleskine notebook using a delicate Blackwing pencil while looking out over the water in Phuket during your sabbatical from your startup? Yeah, but you won’t get anything done. Go ahead and keep doing you and stop reading this post so you can let the serious people do some work. Please don’t do this, you hipster dingus. 2. You are not a good writer. You’re probably a good talker. I’m barely OK as a writer and I’ve been writing for 20 years. So don’t write. Talk. Talk to yourself. Record yourself dictating each scene inside each chapter. Talk out exactly what you want to say, warts and all. Talk for a few minutes or a few hours. Doesn’t matter. Get it all out. Then transcribe it. I have a service I use that I with or you can go online and with robots or whatever. Regardless, this will cost a little money. The result is that you have pages and pages of text to make up that 50,000 word book without having to sit and think about whether you should use “decisive” or “determined” in the first line of your first chapter. In short, I’ve saved you from being a writer. Thank me later. can connect you do it somehow 3. This is the hard part. You need to produce at least 1,000 words a day, every day, for about 60 days. This means you have to take a little time every day and record a chapter or a section of a chapter. You should also be sure that you’ve wrapped your brain around each chapter so you can stop and start at will. Keep doing this until you have at least 80,000 words of transcribed text. “Write” 1,000 words a day. 4. If you don’t think you can turn your vocal ramblings into readable text you’re going to need a . This should cost about $1,500 or so if you find someone who is fresh out of school and doesn’t mind working for peanuts. This person will turn your ramblings into paragraphs and work with you on the text. If you can do this yourself without hitting some kind of vapor lock then go for it. Next you need a . Developmental editors are like coaches. They will move things around and help make things make sense. They ensure you have a consistent thread and turn your mumblings into a real book. Expect to pay about $1,000 for this pleasure. Finally you need a copy editor. This will cost anywhere between $500 and $2,000, depending on who you get. is what a lot of people think of as writing. It’s the process of ensuring that you sound like you speak English (or French or whatever). These folks are integral and expensive because nobody wants to copy edit. Even if you refuse to hire anyone else in this list, pay a copy editor. This is obviously self-serving because I can for you but heck this is 2018 and content has been denigrated to below fish wrapper so why not plug my own crap in a Medium post. You can also go online and ask around but good luck finding someone sane. Hire two or three editors. ghostwriter developmental editor Copy editing source all these people 5. Here’s the sad truth: even if you do all this you probably won’t be published. I love you, broham/etta, but listen: publishers have something to protect and they don’t want weirdos like you horning in on their territory. My advice? Self-pub and use the book as a really thick business card. Hire a cover designer and flow that text into an InDesign template and call it a day and upload it to Amazon. If you think it’s so good that you must sell it in Hudson Newses around the world then you’re going to need to find a literary agent — which isn’t that hard if your book is good but is really hard if you book is meh — and then convince publishers to publish it. I’m going to warn you: publishers don’t care about advanced blockchain factoring techniques in modern data warehouse discovery or whatever you decided to write a book about so you’re better off just self publishing. If you wrote a fiction book about the moon or BDSM, however, you’re probably golden. Be lucky. 6. That’s right: you’re going to write another book. And another. And another. If you think you have only one book in you then thank the lord and go back to your programming or marketing or whatever. If you think you have more to say then you should repeat this for about a decade until you’re really good at it. By this time you will be fat and bitter like me but man if they won’t want you to write (for free) for the Forbes and Inc.contributor network, an honor only bestowed on the best and brightest online marketing scammers and peppy HR managers in the Scranton area. Further, you’ll be able to create multiple calling cards and share your experience and skill with a wide audience and you’ll feel great. Repeat. I just made it easier for you. The key, ultimately, is to figure out what you want to say, figure out who you want to say it to, and say it. If it’s a big enough idea for a book this is how to go about creating it. If it can fit in a Tweet we all might be better off. Either way, good luck! I lied. Writing is hard. Incidentally I have a giant team of editors and writers waiting to help you. Visit typewriter.plus for a quote or just email me at john @ typewriter. plus. You can also read my token sale newsletter here . Main photo by on . rawpixel.com Unsplash Dingus photo by on Matthew Payne Unsplash

How to write a book

Halo2 Circuit Development: Sin7Y Tech Review (20)

LLMs vs Leetcode (Part 1 & 2): Understanding Transformers' Solutions to Algorithmic Problems

এলএলএম বনাম লিটকোড (পর্ব 1 ও 2): অ্যালগরিদমিক সমস্যার জন্য ট্রান্সফরমারের সমাধান বোঝা

LLMs vs. Leetcode (Teil 1 und 2): Transformer-Lösungen für algorithmische Probleme verstehen

LLM vs Leetcode (Parte 1 y 2): Comprensión de las soluciones de los transformadores a problemas algorítmicos

LLM vs Leetcode (parties 1 et 2) : comprendre les solutions des transformateurs aux problèmes algorithmiques

एलएलएम बनाम लीटकोड (भाग 1 और 2): एल्गोरिदमिक समस्याओं के लिए ट्रांसफॉर्मर्स के समाधान को समझना

LLM 対 Leetcode (パート 1 と 2): アルゴリズムの問題に対する Transformer のソリューションを理解する

LLM과 Leetcode(1부 및 2부): 알고리즘 문제에 대한 변환기의 솔루션 이해

LLMs vs Leetcode (Parte 1 e 2): Compreendendo as soluções dos transformadores para problemas algorítmicos

LLM против Leetcode (части 1 и 2): понимание решений алгоритмических задач с помощью трансформаторов

Yüksek Lisans ve Leetcode (Bölüm 1 ve 2): Transformers'ın Algoritmik Sorunlara Çözümlerini Anlamak

LLM và Leetcode (Phần 1 & 2): Tìm hiểu giải pháp của Transformers cho các vấn đề thuật toán

LLM 与 Leetcode（第 1 部分和第 2 部分）：了解 Transformers 对算法问题的解决方案

How I Saved My Newsletter From Bots With Machine Learning

A key technique in image editing applications is determining the dominant colors. The identification of these dominant colors is essential for creating an image's palette, which, in turn, accurately reflects the effect of selected tools and the results of editing. This article will delve into how to determine an image's palette within a restricted color space, identify an image's dominant colors, and differentiate between a palette and dominant colors. Palette The image palette is typically a reference to all the colors present in the original image. In essence, it captures the entire range of color shades, based on the numerical scale of color stimulus signal values. If we agree on modeling a signal with a certain level of accuracy, then the range of these signal values will represent our available color palette. Each unique representation of an image and the mapping of an image's colors onto this space will be a subset of it. In digital signal processing (an image is also a signal), we often understand a variety of quantities through its discrete representation. Thus, our image palette can be viewed as a subset of all the colors in the image represented by a discrete map. Each color can be indexed and assigned a specific value in one of the color spaces. For our purposes, we'll use the RGB color model. A significant challenge in presenting the image palette in this way is the vastness of human visibility. It's unlikely we can manually analyze the entire image palette, and it often doesn't make sense to store an image represented by all the original colors. Instead, we reduce their number to a reasonable limit. This process, known as color quantization, involves lowering the number of colors from the full subset that can be represented in an image to a smaller one. For instance, 14-bit raw color data might be represented in 8-bit JPEG or 16-bit TIFF converted to 8-bit PNG. A straightforward solution to determine an image's primary colors is to envision the process of color quantization to a very limited set, such as 8 or even 3 colors. This gives us insight into the primary colors within the image, making them more noticeable and memorable. Ideally, the colors in the final image should be harmonious, following the principles outlined by or . Johannes Itten Matyushin By identifying the dominant colors of an image, we can create a tool that allows us to visualize the image's "harmony." This can also apply to the harmony of the image after filtering, or "synthetic harmonization." Below, we will make an attempt to develop such a tool. Median Cut A widely used and high-quality algorithm for compressing an image's palette is the Median Cut algorithm. It's incorporated into most major lossy image compression algorithms, such as JPEG, albeit with some modifications. The fundamental principle of the Median Cut algorithm is to sequentially divide the image's cubic histogram into medians. Each resulting subcube contains approximately an equal number of bins, or pixels of the same color. Once the division process reaches a predetermined number of subcubes, we calculate the average color of each cube and map it to the corresponding colors of the original image. This process effectively reduces the number of colors in the original image, allowing us to compress the image into a smaller file size. It might seem at first glance that the initial part of this algorithm could solve our problem of identifying the primary or dominant colors of an image. However, a potential issue arises when the number of colors into which we divide the image is too few, and we're only analyzing a small number of colors. We might end up identifying colors that don't actually exist in the image because the colors are excessively averaged. We could choose the color with the maximum bin from each cube and label it as dominant, but then it wouldn't constitute a palette anymore. So, we'll reserve this approach for determining of the image's palette, which can also be used as a tool for visually analyzing the image in terms of its "harmonious utility." To identify the dominant colors, we'll employ statistical analysis: searching for local maxima in the same cubic histogram. a compressed version Local Maxima To identify the local maxima, we will implement a specific code. The author, who is also a skilled artist, provides an excellent description of the algorithm. Essentially, we first gather the image statistics into the same three-dimensional RGB histogram used in the Median Cut algorithm. Each cell of the cubic histogram will contain color bins, and the sum of all values of each color included in the cell. Given the limited histogram dimension to a resolution of 32x32x32 (originally 30x30x30), accumulating the sum simplifies the calculation of the average cell color. We then search for the local maximum by thoroughly exploring the entire space and comparing it with neighboring cells. Following this, we iteratively reduce the number of local maxima to the required amount, discarding similar colors with less weight. For all remaining local maxima, we calculate the average colors of all values included in the list. Since the color density in local maxima is higher, and the difference between pixel values is smaller than in cubes from the Median Cut, the colors will be more akin to those present in the main image and will more accurately represent its dominant colors. This reveals the primary difference between the two models: acquiring a versus searching for local maxima or . By mapping the primary "compressed palette" image, we will create a new one , albeit in a vastly truncated form. "compressed palette" dominant colors that maintains the same color balance as the main image On the other hand, dominant colors . They cannot be transformed into anything new with a suitable color balance. only describe the composition of the colors primarily present in the image Implementation Using this task as an example, we will demonstrate how straightforward it is to develop a ready-to-use application for image analysis and manipulation using the . We will begin with functionalities that are absent in other engines. IMProcessing Framework For instance, the framework has the capacity to read Adobe files with pre-existing CLUTs and can extract a three-dimensional cubic histogram from an image in real-time. .cube Capitalizing on this, we aim to create an application that can: Upload files in JFIF (jpeg) format. “Normalize” the original image. Control the intensity of the “normalizer.” Incorporate an arbitrary LUT from an Adobe .cube file into the processing. Manage the intensity of CLUT's impact. Display a linear histogram of the image. Exhibit the “compressed palette” and dominant colors of the image as well as their numerical representation in the form of a triplet (r,g,b) The end product of our construction will resemble this interactive toy: Here, it's clear how the image's simple “normalization” positively influences the diversity of the final palette, re-distributing dominant colors into a more varied and harmonious set. "Normalizer" We will assemble a filter from two pre-existing ones: - allows the stretching of the image histogram to specified boundaries IMPContrastFilter - performs automatic white balance correction based on the search for the average color and the correction of spurious tones in the image. This is essentially a slight modification of an idea borrowed from IMPAutoWBFilter . Andrey Zhuravlev’s blog import IMProcessing
 
/// Image filter
public class IMPTestFilter:IMPFilter {
 
    /// We will use a contrast control filter through histogram stretching
    var contrastFilter:IMPContrastFilter!
 
    /// Auto white balance filter
    var awbFilter:IMPAutoWBFilter!
 
    /// Image Linear Histogram Analyzer
    var sourceAnalyzer:IMPHistogramAnalyzer!
 
    /// Solver of the histogram analyzer for calculating the lightness boundaries of the image
    let rangeSolver = IMPHistogramRangeSolver()
 
    public required init(context: IMPContext) {
        super.init(context: context)
 
        //  Initialize filters in context
        contrastFilter = IMPContrastFilter(context: context)
        awbFilter = IMPAutoWBFilter(context: context)
 
        // Add filters to the stack
        addFilter(contrastFilter)
        addFilter(awbFilter)
 
        // Initialize the histogram analyzer
        sourceAnalyzer = IMPHistogramAnalyzer(context: self.context)
 
        // Add a light boundary search solver to the analyzer
        sourceAnalyzer.addSolver(rangeSolver)
 
        // Add an observing handler to the filter for
        // to pass the current image frame to the analyzer
        addSourceObserver { (source) - Void in
            self.sourceAnalyzer.source = source
        }
 
        // Add an observing handler for updating analysis calculations to the analyzer
        sourceAnalyzer.addUpdateObserver({ (histogram) - Void in
        // set the lightness boundaries in the contrast filter each time the image changes
            self.contrastFilter.adjustment.minimum = self.rangeSolver.minimum
            self.contrastFilter.adjustment.maximum = self.rangeSolver.maximum
        })
 
    }
} Palette Solver The IMProcessing Framework stands out from many similar platforms due to its unique organization of calculations. It uses a dedicated group of filters that essentially are not processing filters. The objects of these classes do not modify the image in the homogeneous and spatial domains. Instead, they perform certain calculations and representations of metrics for analysis in special expanders to solve specific problems. For instance, an object of the IMPHistogramAnalyzer class can simultaneously add multiple solvers that calculate the average color of the image, the light range, zonal division, etc. We use the solver to extend the analysis of IMPHistogramCubeAnalyzer to calculate the palette and the list of dominant colors. The calculation results are then displayed in an updated NSTableView. import IMProcessing
 
///  Types of distribution of image color accents
///
///  - palette:   palette for quantizing image colors.
///               calculated using the median-cut transformation scheme:
///               http://www.leptonica.com/papers/mediancut.pdf
///  - dominants: calculation of dominant colors of an image by searching for local maxima
///               color distribution density functions:
///               https://github.com/pixelogik/ColorCube
///
public enum IMPPaletteType{
    case palette
    case dominants
}
 
/// Solver of the cubic color histogram analyzer IMPHistogramCubeAnalyzer
public class IMPPaletteSolver: IMPHistogramCubeSolver {
 
    /// Maximum number of palette colors for analysis
    public var maxColors = Int(8)
 
    /// List of found colors
    public var colors = [IMPColor]()
 
    /// Palette type
    public var type = IMPPaletteType.dominants
 
	  /// Solver handler handler
    /// - parameter analyzer: link to the analyzer
    /// - parameter histogram: cubic histogram of the image
    /// - parameter imageSize: image size
    public func analizerDidUpdate(analizer: IMPHistogramCubeAnalyzer, histogram: IMPHistogramCube, imageSize: CGSize) {
 
        var p = [float3]()
        if type == .palette{
            p = histogram.cube.palette(count: maxColors)
        }
        else if type == .dominants {
            p = histogram.cube.dominantColors(count: maxColors)
        }
 
        colors.removeAll()
 
        for c in p {
            colors.append(IMPColor(color: float4(rgb: c, a: 1)))
        }
    }
} We Assemble All the Components in the View Controller The controller will need the main application filter, which we'll call , a CLUT filter named IMPLutFilter, the ready-to-use IMPHistogramView for displaying a "regular" histogram, the IMPHistogramCubeAnalyzer which is a cubic histogram analyzer to which we will attach our solver, the IMPPaletteSolver. IMPTestFilter Lastly, we'll use IMPImageView as the main window for displaying the image, and the common IMPContext is the key class used by all constructors of the framework. class ViewController: NSViewController {
 
    //
    // Processing context
    //
    let context = IMPContext()
    //
    // Window for presenting the loaded image
    //
    var imageView:IMPImageView!
 
    var pannelScrollView = NSScrollView()
 
    //
    // Window for displaying the image histogram
    //
    var histogramView:IMPHistogramView!
 
    //
    // NSTableView - views of a list of colors from the palette
    //
    var paletteView:IMPPaletteListView!
 
    //
    // Main filter
    //
    var filter:IMPTestFilter!
 
    //
    // CLUT filter from Adobe Cube files
    //
    var lutFilter:IMPLutFilter?
 
    //
    // Analyzer of a cubic histogram of an image in RGB space
    //
    var histograCube:IMPHistogramCubeAnalyzer!
 
    //
    // Our solver for finding colors
    //
    var paletteSolver = IMPPaletteSolver()
 
    var paletteTypeChooser:NSSegmentedControl!
 
    override func viewDidLoad() {
 
        super.viewDidLoad()
 
        configurePannel()
 
        //
        // Initialize the objects we need
        //
 
        filter = IMPTestFilter(context: context)
 
        histograCube = IMPHistogramCubeAnalyzer(context: context)
        histograCube.addSolver(paletteSolver)
 
        imageView = IMPImageView(context: context, frame: view.bounds)
        imageView.filter = filter
        imageView.backgroundColor = IMPColor(color: IMPPrefs.colors.background)
 
        //
        // Add another handler to monitor the original image
        // (another one was added in the main filter IMPTestFilter)
        //
        filter.addSourceObserver { (source) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            //
            // to minimize calculations, the analyzer will compress the image to 1000px on the wide side
            //
            if let size = source.texture?.size {
                let scale = 1000/max(size.width,size.height)
                self.histograCube.downScaleFactor = scale.float
            }
        }
 
        // Add an observer to the filter to process the filtering results
        //
        filter.addDestinationObserver { (destination) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
 
            // pass the image to the histogram indicator
            self.histogramView.source = destination
 
            // pass the result to the cubic histogram analyzer
            self.histograCube.source = destination
        }
 
        //
        // The results of updating the analyzer calculation are displayed in the color list window
        //
        histograCube.addUpdateObserver { (histogram) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                self.paletteView.colorList = self.paletteSolver.colors
            })
        }
 
        view.addSubview(imageView)
 
....
 
        IMPDocument.sharedInstance.addDocumentObserver { (file, type) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            if type == .Image {
                do{
                    //
                    // Load the file and associate it with the filter source
                    //
                    self.imageView.source = try IMPImageProvider(context: self.imageView.context, file: file)
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        self.zoomFit()
                    })
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
            else if type == .LUT {
                do {
 
                    //
                    // Initialize the CLUT descriptor
                    //
                    var description = IMPImageProvider.LutDescription()
                    //
                    // Load CLUT
                    //
                    let lutProvider = try IMPImageProvider(context: self.context, cubeFile: file, description: &amp;amp;amp;amp;amp;amp;amp;amp;amp;description)
 
                    if let lut = self.lutFilter{
                        //
                        // If a CLUT filter has been added, update its LUT table from the file with the received descriptor
                        //
                        lut.update(lutProvider, description:description)
                    }
                    else{
                        //
                        // Create a new LUT filter
                        //
                        self.lutFilter = IMPLutFilter(context: self.context, lut: lutProvider, description: description)
                    }
 
                    //
                    // Add a LUT filter, if this filter has already been added nothing happens
                    //
                    self.filter.addFilter(self.lutFilter!)
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
        }
 
   .... As you can see, photo processing is becoming simpler and more accessible to average users, making it possible for virtually anyone to master this process. The entire project can be downloaded, assembled, and tested from the project : . For proper assembly, the mega-library for working with JPEG files (JFIF), , must be locally installed. ImageMetalling repository ImageMetalling-08 libjpeg-turbo Currently, this is the best implementation of support for this format.

How to Create an Application to Determine the Palette and Dominant Colors of an Image

একটি চিত্রের প্যালেট এবং প্রভাবশালী রঙ নির্ধারণের জন্য কীভাবে একটি অ্যাপ্লিকেশন তৈরি করবেন

So erstellen Sie eine Anwendung zum Bestimmen der Palette und der vorherrschenden Farben eines Bildes

Cómo crear una aplicación para determinar la paleta y los colores dominantes de una imagen

Comment créer une application pour déterminer la palette et les couleurs dominantes d'une image

किसी छवि के पैलेट और प्रमुख रंगों को निर्धारित करने के लिए एप्लिकेशन कैसे बनाएं

画像のパレットと主要な色を決定するアプリケーションを作成する方法

이미지의 팔레트 및 주요 색상을 결정하는 응용 프로그램을 만드는 방법

Como criar um aplicativo para determinar a paleta e as cores dominantes de uma imagem

Как создать приложение для определения палитры и доминирующих цветов изображения

Bir Görüntünün Paletini ve Baskın Renklerini Belirlemeye Yönelik Uygulama Nasıl Oluşturulur

Cách tạo một ứng dụng để xác định bảng màu và màu chủ đạo của hình ảnh

如何创建应用程序来确定图像的调色板和主色

So, this is absolutely just another example of me playing around too much, but I had to share. As I mentioned in my yesterday, Google's AI Studio now supports uploading files and working with them in your prompt. post Today, I decided to give the Chat interface a try as I hadn't yet played with it. On a whim, I googled "dungeons and dragons rules PDF" and... well, you won't believe what happened next. (Sorry, I couldn't resist.) First off, the most important thing to note if you want to test with PDFs, ensure that they are OCRed. Right now, AI Studio does not handle that well, but it should be corrected in the future. My Google search turned up the PDF here: , and I confirmed it was properly OCRed with a very scientific test by trying to select a few words. https://media.wizards.com/2018/dnd/downloads/DnD_BasicRules_2018.pdf Note that it's from 2018 and probably a bit out of date, but I figured it was good enough. I uploaded the PDF to Gemini and ensured I was using Gemini 1.5. This is important as the size of the PDF (180 pages) means a rather large token size. The UI reports this nicely: For my first test, I simply asked, "What are the attributes of a player character?" Here's what I got: In Dungeons & Dragons, player characters (PCs) are defined by several key attributes: Race: This determines your character's physical characteristics, ancestry, and innate abilities. Examples include humans, elves, dwarves, halflings, dragonborns, tieflings, etc. Each race has unique traits that affect gameplay. Class: This represents your character's chosen profession and determines their skills, abilities, and progression path. Examples include fighter, wizard, rogue, cleric, bard, etc. Each class has unique features and abilities that define their role in the party. Ability Scores: These six scores represent your character's core physical and mental capabilities: Strength, Dexterity, Constitution, Intelligence, Wisdom, and Charisma. They influence almost every action your character takes, from attacking and defending to interacting with the world and casting spells. Skills: These represent specific areas of expertise your character has developed through training or experience. Examples include Athletics, Acrobatics, Stealth, Perception, Persuasion, Arcana, etc. Skills are tied to ability scores and determine your character's success in various tasks. Background: This details your character's history and past experiences before becoming an adventurer. Examples include soldier, criminal, noble, sage, etc. Backgrounds provide additional skills, proficiencies, and roleplaying hooks. Equipment: This includes weapons, armor, tools, and other items your character carries. Equipment affects your character's capabilities in combat and exploration. Personality and Alignment: These define your character's moral compass, beliefs, and behavior. Alignment is a combination of two factors: morality (good, evil, or neutral) and attitude towards society and order (lawful, chaotic, or neutral). Backstory: This is the narrative of your character's life before the game begins, including their motivations, goals, and relationships. A well-developed backstory adds depth and helps you roleplay your character. These attributes work together to create a unique and well-rounded character that you can roleplay and guide through adventures in the D&D world. I'm pretty rusty in D&D, but that surely seems right! (When I shared this in a chat related to Gemini, William Ito skimmed it and said it looks correct for that era - so, I'm taking that as another sign it worked well.) I then asked, "What races are available to player characters?" The most common player character races in Dungeons & Dragons are: Humans: Adaptable and versatile, with no major strengths or weaknesses. Elves: Graceful and long-lived, with a natural affinity for magic and a resistance to charm effects. Subraces include High Elves, Wood Elves, and Dark Elves (Drow). Dwarves: Stout and hardy, with a resistance to magic and poison, and proficiency in combat and craftsmanship. Subraces include Hill Dwarves and Mountain Dwarves. Halflings: Nimble and small, with a natural ability to hide and a resistance to fear. Subraces include Lightfoot Halflings and Stout Halflings. The Player's Handbook also introduces several less common races, including: Dragonborn: Proud and draconic humanoids with scales and the ability to breathe fire. Tieflings: Demonic descendants with a natural affinity for magic and resistance to fire. Gnomes: Inventive and curious small creatures with a natural ability to tinker and a resistance to magic. Half-elves: Combining human and elven traits, they are versatile and have a resistance to charm effects. Half-orcs: Combining human and orc traits, they are strong and fierce with a resistance to being knocked unconscious. Additionally, some campaign settings and sourcebooks introduce even more exotic races, such as Aasimar, Firbolg, Goliath, Aarakocra, Genasi, and many others. The availability of these races depends on your Dungeon Master and the specific campaign setting you are playing in. Remember, the most important factor in choosing a race is to pick one that excites you and fits the character concept you have in mind. I have absolutely no clue if those exotic races exist, but I did a quick search on Aasimar, and it looks like it certainly does: Aasimar Alright, now, at this point, I was impressed. But I thought - why not push my luck? "Given the rules to create a character, create one with all the required characters and give it a name" And holy crap - Gemini delivered! Character Name: Lyra Swiftfoot Race: Lightfoot Halfling Class: Rogue (Thief) Background: Entertainer (Dancer) Alignment: Chaotic Good Ability Scores: (Using the standard set) Strength: 8 (-1) Dexterity: 17 (+3) Constitution: 14 (+2) Intelligence: 13 (+1) Wisdom: 12 (+1) Charisma: 15 (+2) Hit Points: 10 (8 + 2 from Constitution modifier) Proficiencies: Armor: Light armor Weapons: Simple weapons, hand crossbows, longswords, rapiers, shortswords Tools: Thieves' tools, Disguise kit (from background) Saving Throws: Dexterity, Intelligence Skills: Acrobatics (+5), Perception (+4), Performance (+6), Stealth (+7) (Expertise in Stealth and Performance) Equipment: Rapier Shortbow and quiver of 20 arrows Leather armor Two daggers Thieves' tools Disguise kit Backpack Bedroll Mess kit Tinderbox 10 torches 10 days of rations Waterskin 50 feet of hempen rope Pouch with 15 gp Personality Traits: I have a quick wit and a fondness for pranks. I am fiercely loyal to my friends and always look out for their safety. Ideal: Freedom: Everyone should be free to live their life as they see fit. (Chaotic) Bond: I will do anything to protect my younger sister, who is the only family I have left. Flaw: I have a weakness for shiny objects and can't resist the urge to steal them, even if it means putting myself at risk. Backstory: Lyra grew up on the streets, using her nimbleness and charm to survive. She learned to dance for coins and honed her skills in stealth and deception to pilfer from unsuspecting onlookers. After her sister was kidnapped by slavers, Lyra vowed to do whatever it takes to find and rescue her, even if it means venturing into the darkest corners of the world. This is just a basic example, and you can further customize Lyra by adding details to her appearance, personality, and backstory. You can also choose different skills, proficiencies, or equipment based on your preferences and the campaign setting. By the way, the formatting above is a bit off, but that came from me copying and pasting from Gemini and being a bit lazy about sprucing it up. I figured I'd push my luck and try again: "do that again please" Character Name: Falion Sunstrider Race: High Elf Class: Wizard (Evocation) Background: Sage (Researcher) Alignment: Neutral Good Ability Scores: (Using the standard set) Strength: 8 (-1) Dexterity: 14 (+2) Constitution: 13 (+1) Intelligence: 17 (+3) Wisdom: 12 (+1) Charisma: 10 (+0) Hit Points: 8 (6 + 1 from Constitution modifier) Proficiencies: Weapons: Daggers, darts, slings, quarterstaffs, light crossbows Tools: None Saving Throws: Intelligence, Wisdom Skills: Arcana (+6), History (+6), Investigation (+4) (Expertise in Arcana and History) Equipment: Quarterstaff Arcane focus (crystal) Scholar's pack Spellbook with six 1st-level wizard spells (Burning Hands, Charm Person, Detect Magic, Mage Armor, Magic Missile, Shield) Backpack Bedroll Mess kit Tinderbox 10 torches 10 days of rations Waterskin 50 feet of hempen rope Pouch with 10 gp Personality Traits: I am deeply curious about the world and always eager to learn new things. I am absent-minded and often lost in my own thoughts. Ideal: Knowledge: The path to power and self-improvement is through knowledge. (Neutral) Bond: I am searching for the lost library of a legendary archmage, rumored to contain powerful spells and forgotten lore. Flaw: I am overconfident in my abilities and sometimes underestimate the dangers I face. Backstory: Falion spent his youth studying in a prestigious academy of magic, quickly surpassing his peers with his thirst for knowledge and natural talent for evocation magic. After hearing rumors of a lost library containing powerful spells and forgotten lore, Falion set out on a journey to find it, hoping to unlock its secrets and further his magical abilities. This is just a basic example, and you can further customize Falion by adding details to his appearance, personality, and backstory. You can also choose different skills, proficiencies, or equipment based on your preferences and the campaign setting. So, at this point, I was blown away. Like, I don't even care if it broke any particular D&D rules; that was just fun. But... yeah, I pushed my luck ... ... ... one last time "Of the two characters you just made, who do you think would be a better party leader?" Between Lyra Swiftfoot and Falion Sunstrider, Lyra would likely be the better party leader for several reasons: : Lyra has a higher Charisma score, which is important for inspiring and motivating others. Her background as an entertainer also suggests she is comfortable in front of crowds and skilled at interacting with people. Charisma : Lyra's skillset is more suited to leadership. Her expertise in Persuasion and Deception allows her to negotiate effectively and navigate social situations, while her proficiency in Perception and Stealth makes her a good scout and strategist. Skills : Lyra's personality traits suggest she is quick-witted and loyal, both valuable qualities in a leader. Her flaw, while potentially problematic, can be mitigated by her other strengths and the support of her party. Personality : While wizards can be powerful, their focus on spellcasting and relative lack of social skills often makes them less effective leaders. Class Falion, on the other hand, excels in knowledge and magical power, making him a valuable asset to the party in terms of strategy and information gathering. However, his lower Charisma and lack of social skills might hinder his ability to effectively lead and inspire others. Additionally, his absent-mindedness and overconfidence could lead to poor decisions in critical situations. Of course, the effectiveness of a party leader also depends on the specific campaign setting, the party composition, and the players' roleplaying preferences. In some situations, Falion's knowledge and magical prowess might be more valuable than Lyra's social skills. Ultimately, the best party leader is the one that the players and the Dungeon Master agree upon and who can effectively guide the party through their adventures. My god. That's just... perfect. And honestly, it feels like the right choice for the right reasons. Anyway, this isn't necessarily a deep look at this particular feature, but it was so fun I had to share!

Google Gemini: Your New Dungeon Master?

গুগল মিথুন: আপনার নতুন অন্ধকূপ মাস্টার?

Google Gemini: Ihr neuer Dungeon-Meister?

Google Gemini: ¿tu nuevo maestro de mazmorras?

Google Gemini : votre nouveau maître de donjon ?

गूगल जेमिनी: आपका नया कालकोठरी मास्टर?

Google Gemini: あなたの新しいダンジョンマスター?

Google Gemini: 새로운 던전 마스터?

Google Gemini: seu novo mestre de masmorras?

Google Gemini: ваш новый мастер подземелий?

Google Gemini: Yeni Zindan Ustanız mı?

Google Gemini: Chủ nhân ngục tối mới của bạn?

谷歌双子座：你的新地下城主？

This is the second part in a multi-part series on building Agents with OpenAI's Assistant API using the Python SDK. Recap of Part 1 In of this series, we created a simple conversational Agent using the OpenAI Assistant API. Part 1 Let's recall our definition of an Agent. An agent is a piece of software leveraging an aiming to mimic human behavior. That means it can not only converse and understand language, but it can also perform actions that have an impact on the real world. These actions are typically called tools. LLM (Large Language Model) I use the terms and interchangeably when it comes to functions that the agent is able to call. OpenAI also uses the term interchangeably with to refer to the same concept. It seems the jury is still out on which term will become the standard. tools functions action tools In Part 2 of the series, let's build our first tool! We will be building on top of the simple conversational Agent we built in Part 1. We will purposefully call our implementation an Agent and refer to the as an Assistant to easily distinguish between the two. OpenAI SDK implementation Prerequisites To follow along with this tutorial, you will need the following: Have read or at least copied the as your starting point Part 1 code Python3 installed on your machine An OpenAI API key Basic knowledge of Python programming Dependencies We have one new dependency , a library used for parsing docstrings in Python code. This is needed for our Agent to dynamically interpret and manage the functions it can call. More on this later. docstring_parser python3 -m venv venv
source venv/bin/activate
pip install docstring_parser The goal In Part 1, we created an Agent that represents a famous hobbit who spends too much time thinking about breakfast 🍳 The goal of this tutorial will be to add two abilities or tools to our Agent. The tools will: Add the ability for our Agent to eat a second breakfast if he has only had one or else eat lunch. Add the ability for him to tell us the current date. NOTE: For those of you who don't know, hobbits eat two breakfasts. Also, some humans, like myself... It's a ridiculous example, but it will clearly illustrate the data flow you can set up for more complex use cases that interact with real-world data. Setting up the mock database Let's do a small amount of prep work before we dive in. We will create a simple mock database represented by a new file containing a variable . In this case, the variable will keep track of how many breakfasts our hobbit has eaten. db.py breakfast_count breakfast_count breakfast_count = 1 While we are here, we will update the method on our class to get data from our mock db. get_breakfast_count_from_db Agent import db

class Agent:
    # ... (rest of code)
    def get_breakfast_count_from_db(self):
        return db.breakfast_count 😴... That's out of the way. Let's move on to the fun part. Our first tool A tool is quite simply a function that the Agent is aware it needs to call in a specific scenario. Therefore, let's first define a simple function that handles our breakfast logic. IMPORTANT: I want to draw your attention to the in the tool functions we are about to define. It's crucial to get the documentation syntax right, as this is what will be used to extract the correct OpenAI function format in JSON. More on this soon. Google Style docstring Create a new file with this content: tools.py import db


def eat_next_meal(breakfast_count: int):
    """
    Call this tool when user wants you to eat another meal.

    Args:
        breakfast_count (int): Value with same name from metadata.

    Returns:
        str: The meal you should eat next.
    """
    print("== eat_next_meal ==> tool called")
    
    if breakfast_count == 2:
        return "You have already eaten breakfast twice today. You eat lunch now."
    if breakfast_count == 1:
        db.breakfast_count += 1
        return "You have only eaten one breakfast today. You eat second breakfast now." Pretty simple, right? If is , eat second breakfast and update the database to reflect that 2 breakfasts have been eaten. If is , eat lunch. breakfast_count 1 breakfast_count 2 You could then return any string you want from the tool. This return value is then fed right back into the Run in order to inform the Assistant of the outcome of an action taken. If your agent only cares that the tool was called and completed successfully, you could just return a or message. "success" "failed" Let's quickly create the second tool for our Agent so that we can illustrate how multiple tools can be used. We will create a tool to allow our Agent to tell us what the current date is. def tell_the_date():
    """
    Call this tool when the user wants to know the date.

    Returns:
        str: The current date
    """
    print("== tell_the_date ==> tool called")
    current_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return f"The date is {current_date}" Providing the tools to our Agent Now, let's provide these new tools to our in . We create a dictionary that maps function names to their corresponding callable objects and pass this as the argument to our class instantiation. We could hardcode the dictionary keys as strings, but we all know how easy typos are, so I chose to leverage Python's built-in property on functions to make this less error-prone: Agent main.py tools __name__ from tools import eat_next_meal, tell_the_date

agent = Agent(name="Bilbo Baggins",
              personality="You are the accomplished and renown adventurer from The Hobbit. You act like you are a bit of a homebody, but you are always up for an adventure. You worry a bit too much about breakfast.",
              tools={
                  eat_next_meal.__name__: eat_next_meal,
                  tell_the_date.__name__: tell_the_date
              }) Updating our Agent to accept tools Let's put these new tools into our Agent's tool belt by updating the class constructor to accept a dictionary of tools. You could bake this right into the class using class methods, but since it's common for different Agents to have different functionalities, we will pass tools as a constructor parameter and set them dynamically as a class property for later use. Agent tool_belt class Agent:
    # ... (rest of code)
    def __init__(self, name: str, personality: str, tools: dict[str, callable]):
        self.name = name
        self.personality = personality
        self.client = openai.OpenAI(api_key="sk-*****")

        self.tool_belt = tools
        self.assistant = self.client.beta.assistants.create(
            name=self.name,
            model="gpt-4-turbo-preview",
        ) Our Agent now has a tool belt it can access, but the OpenAI Assistant is unaware of them. We could provide the tools when creating the Assistant ( ) by passing a parameter, but tools can change often in development, and it's clunky to have to update Assistants every time you modify a tool by calling . assistants.create tools assistants.update Therefore, a better approach is to provide the needed tools to every Run so that they are created dynamically each time. Let's do exactly that by adding the parameter to our run creation: tools class Agent:
    # ... (rest of code)
    def _create_run(self):
        count = self.get_breakfast_count_from_db()
        return self.client.beta.threads.runs.create(
            thread_id=self.thread.id,
            assistant_id=self.assistant.id,
            tools=self._get_tools_in_open_ai_format(), # add this line
            # ... (rest of code)
        ) Woah!? Wait a minute... ✋🏻 Where did come from? Why aren't we just passing directly? _get_tools_in_open_ai_format tool_belt Well, let's create that method, and I'll explain right after: import docstring_parser

class Agent:
    # ... (rest of code)
    def _get_tools_in_open_ai_format(self):
        python_type_to_json_type = {
            "str": "string",
            "int": "number",
            "float": "number",
            "bool": "boolean",
            "list": "array",
            "dict": "object"
        }

        return [
            {
                "type": "function",
                "function": {
                    "name": tool.__name__,
                    "description": docstring_parser.parse(tool.__doc__).short_description,
                    "parameters": {
                        "type": "object",
                        "properties": {
                            p.arg_name: {
                                "type": python_type_to_json_type.get(p.type_name, "string"),
                                "description": p.description
                            }
                            for p in docstring_parser.parse(tool.__doc__).params

                        },
                        "required": [
                            p.arg_name
                            for p in docstring_parser.parse(tool.__doc__).params
                            if not p.is_optional
                        ]
                    }
                }
            }
            for tool in self.tool_belt.values()
        ] 😵... Ok, you really don't need to try to understand what each line is doing here since I took the time to work this all out for you. All you need to know is that this method takes the class property and uses the library we installed at the beginning of this tutorial to parse the docstrings of each function and extract the correct . That is why correctly formatting the docstring is so important. tool_belt docstring_parser OpenAI JSON format Otherwise, we would have to define our functions as Python code and define them again manually in the OpenAI JSON format. That's too much room for human error in my book. Polling for tool calls As we saw in Part 1, we have a polling mechanism to determine the current of a Run. One of these statuses is . This means the assistant has determined that one or several tools need to be called based on the instructions and tool definitions provided. The Run will not continue until all the tools have been called and the results of those calls have been submitted to the Run. status requires_action Let's, therefore, update our method to respond appropriately to the status: _poll_run requires_action class Agent:
    # ... (rest of code)
    def _poll_run(self, run: Run):
        status = run.status
        start_time = time.time()
        while status != "completed":
            if status == 'failed':
                raise Exception(f"Run failed with error: {run.last_error}")
            if status == 'expired':
                raise Exception("Run expired.")
            # add the below code block
            if status == 'requires_action':
                self._call_tools(
                    run.id, run.required_action.submit_tool_outputs.tool_calls)

            # ... (rest of method) As you might have guessed, will contain all the logic to dynamically call the available tools. _call_tools Remember, the Assistant only knows what tools need to be called but doesn't actually call them. The Run returns a list of dictionaries, , that contain the names of the functions that need to be called along with the parameters to pass to those function calls. It's up to our custom Agent implementation to obey the Assistant's commands and call the actual function implementations. run.required_action.submit_tool_outputs.tool_calls Let's implement . We'll break this down as code comments so it's easier to understand what is happening: _call_tools import json

class Agent:
    # ... (rest of code)
    def _call_tools(self, run_id: str, tool_calls: list[dict]):
        # We create a tool_outputs list to collect the results of function calls.
        tool_outputs = []

        # We iterate over all the tool_calls to deal with them individually
        for tool_call in tool_calls:
            # We get the `function` object from the tool_call
            function = tool_call.function
            # We extract the arguments from the function object.
            # They are in JSON so we need to load them with the json module.
            function_args = json.loads(function.arguments)
            # We map the function name to our callable function in our Agent's tool belt.
            function_to_call = self.tool_belt[function.name]
            # We can now call the function with the provided arguments.
            function_response = function_to_call(**function_args)
            # We append the response to the tool_outputs list
            tool_outputs.append(
                {"tool_call_id": tool_call.id, "output": function_response})

        # Finally, we submit the tool outputs to OpenAI
        self.client.beta.threads.runs.submit_tool_outputs(
            thread_id=self.thread.id,
            run_id=run_id,
            tool_outputs=tool_outputs
        ) Once the OpenAI method has been called with all the tool call outputs, we have completed the requirements for the Run to move past the status. The status will then switch to before eventually reaching the status and returning a response to the user. submit_tool_outputs requires_action in_progress completed Running it Let's give it a run: python3 main.py

User: Good morning

Assistant: Good morning! What an excellent day it seems for an adventure... or perhaps for a hearty breakfast first. How can I assist you on this fine day?

User: Should you eat breakfast?

== eat_next_meal ==> tool called

Assistant: Ah, only one breakfast so far? Well then, it's clear what must be done. It's time for a second breakfast!

User: You should eat another meal.

== eat_next_meal ==> tool called

Assistant: Ah, having already enjoyed both breakfast and second breakfast, it seems it's time to move on to lunch! This is turning into quite the day of culinary adventures.

User: What day is it?

== tell_the_date ==> tool called

Assistant: It's the 19th of February, 2024. Seems like a perfect day to embark on a quest or to delve into the mysteries of Middle-earth. What plans do we have for today? Voilà! Your hobbit can tell the date and eat the correct meal now. Even though this example is quite silly, my intention is to provide you with a functioning code sample to build your own powerful agents. In Part 3, we will implement RAG (Retrieval Augmented Generation) using PostgreSQL. Wait, what? OpenAI Assistants have that built-in; why not use their implementation? I'll explain my reasoning in Part 3. Thank you for your reading. Happy to hear any thoughts and feedback in the comments. for more content like this. Follow me on Linkedin

How to Build an Agent With an OpenAI Assistant in Python - Part 2: Function Calling / Tools

SELFBOOK

selfbook.com

-- employees

Since n.d.

COMPANY RANKING

SELFBOOK

EVERGREEN INDEX #10005

Representing this company? Click here to claim and customize this page!

Selfbook WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

SELFBOOK

selfbook.com

-- employees

Since n.d.

COMPANY RANKING

SELFBOOK

EVERGREEN INDEX #10005

RELATED COMPANIESRANK

STORIES ABOUT SELFBOOK

Representing this company? Click here to claim and customize this page!

Selfbook WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!