DEV Community: Fabrizio Cafolla

ChatGPT the new era of AI | OpenaAI

Fabrizio Cafolla — Tue, 17 Jan 2023 21:00:46 +0000

ChatGPT the new era of AI | OpenaAI

Introduction.

This article comes from my desire to experiment with OpenAI's ChatGPT.

I was intrigued by the recent hype around it, with some people condemning it while others can't get enough of it, so I had to test it out for myself to form my own opinion.

The initial idea was to test the power of this AI, but it quickly evolved into an open-source project. I thought about creating a command for performing text translations from the command line using OpenAI's APIs, so I implemented a Python script that takes in text or a file and then asks ChatGPT to translate it into the desired language.

Nothing special in terms of code, but it gave me a good overview of this technology.

https://github.com/FabrizioCafolla/opentranslator

ChatGPT overview

ChatGPT, released in November 2022, is a chatbot created by OpenAI, based on the GPT-3.5 language model, meaning it can answer questions, write essays, summarize long texts, translate languages, and even create code. GPT-3 was released in 2020 and in December 2022 GPT-3.5 was released, a high performing model with the ability to provide very human-like conversational responses, trained with over 750GB of data collected from various sources. After reading several sources, I found one that explains the functioning of the model and its training very well (deepen source).

Algorithms are not public and the data used to train them is not well-defined, or rather, most of the sources are from Common Crawl, Reddit, Books, and Wikipedia, but we don't know which data was taken into consideration nor whether there are copyrighted data which could make the responses inaccurate or under a license.

It is not said that OpenAI will not make the GPT-3 model open source in the future, as it has already done with the Whisper model for voice recognition, another important aspect, there are models like LaMDA that are still not available to the public but when they are released they will raise the bar even higher. Certainly, the success it is having in terms of use is good for the AI world, even non-professionals are starting to use ChatGPT, some for fun, some out of curiosity and some are starting to integrate it into their work.

The energy cost for the computational calculations of the training is another important factor, the training requires enormous computing power and therefore an equal energy consumption, all of which translates into costs for the users (the current APIs are very expensive in my opinion).

Project

Mine is a small project to interact with the OpenAi API which is accessible only through a token that has to be created from your own profile, if you don't have a profile you can create it for free, once created you will have a 3 month "Free trial" with a credit of 18$.

Once you have generated the key copy it and add it to your environment variables so that it is usable by the user in any context.

From the terminal install the opentranslator package:

pip install opentranslator

Now you can use the terminal command:

opentranslator --translate english --text "Ciao, mondo!"

opentranslator --translate english --filepath {FILENAME}

This simple command will allow you to translate into all languages supported by chatgpt directly from the terminal.
Be aware that API calls have a variable cost based on the number of characters sent and the complexity of computation, plus there is a maximum character limit per request based on the engine used.

Considerations

The first consideration I want to make is this: why be afraid of AI?

Many have raised doubts about how this technology can harm humans, thinking, creativity and many other things that make us feel unique, but I wonder what they are afraid of.

The fact that an AI can do creative drawings does not mean that it is art, the fact that an AI can do summaries does not mean that we will forget how to do them, the fact that an AI can write code will not make programmers disappear. What scares me more is who uses the technology and not the technology itself.

Cars didn't make us forget how to walk, so why should AI make us forget how to think?

All the outraged and scared should fear social networks much more than a technology created to facilitate people in performing more or less complicated tasks.

Revolution can be scary, but it must be faced, because of how much it can change the lives of people with disabilities. Glasses that transcribe lip reading in real time, devices that can alert a blind person to imminent dangers, help dyslexics understand a text, use in the processing of molecules to create and study drugs, and many other ideas that could facilitate and improve everyday life and work.

The future that lies ahead of us gives us the opportunity to use machines to improve our lives and man must find the right symbiosis with them.

Another consideration is the paternity of the answers, as mentioned before, the algorithms are not public and the data used are not clear. This could lead to copyright violations, debates are already being fueled in this regard, and a concrete petition has been made by the artistic world (article) denouncing applications such as Midjourney for having used works of artists to train the model without the consent of the authors. So in the future there will be many legal and ethical aspects to be faced before this technology can be defined as usable.

Summing up, I think it is still too early to have an outcome that will radically change the world of work or everyday life, still too immature, but definitely, something that will become more and more performant and accurate in the coming years. We will have to be very careful about the ethics and use of this technology because it could be used for non-legal purposes, or it could bring discrimination in decision-making, and many other things that would harm people or infrastructure. That is why Google and Microsoft, with the LaMDA and VALL-E models, respectively, state that they are tools with a great capacity, but that before they make them accessible they must ensure that they comply with some fundamental principles.

DALL-E

OpenAI's DALL-E project is an artificial intelligence system that generates images from textual descriptions. The system was developed using a deep neural network (Deep Learning) and a machine learning technique called "transfer learning". The system is able to generate realistic images from a textual description, such as "a cat with a cowboy hat". **

Paint an oil painting of a dystopian future similar to Blade Runner

Oil painting on canvas of the Pontine marsh in Victorian style

Human fighting with lucifer, oil on canvas like Michelangelo

** This text was generated by ChatGPT

Resources

https://www.assemblyai.com/blog/how-chatgpt-actually-works/

https://www.springboard.com/blog/data-science/machine-learning-gpt-3-open-ai/

https://scholar.harvard.edu/saghafian/blog/analytics-science-behind-chatgpt-human-algorithm-or-human-algorithm-centaur

https://www.forbes.com/sites/bernardmarr/2020/10/05/what-is-gpt-3-and-why-is-it-revolutionizing-artificial-intelligence/?sh=18296ec3481a

https://www.nytimes.com/2022/04/15/magazine/ai-language.html

https://codeforces.com/blog/entry/109815

https://blog.google/technology/ai/lamda/

https://www.blog.google/technology/ai/ai-principles/

Open source is mainstream, and a new era is on the horizon!

Fabrizio Cafolla — Sat, 08 Oct 2022 13:35:31 +0000

Open source is mainstream, and a new era is on the horizon!

Overview

The open source world is mainstream! It has more than two decades behind it now; it came to life in 1998 with the Open Source Initiative (OSI), but back in the mid-1980s the Free Software Foundation (FSF) started the revolution: of software freedom (1).

The term open source may have multiple definitions, but it has constants; it must be:

Accessible both source code and compiled
Derviable, meaning it can be modified and redistributed (under the same conditions as the original licenses)
Nondiscriminatory

As I read and combed through articles and publications, it became clear how the market has changed and is currently in a Renaissance phase.
To make a long story short we can group the phases of software into (2):

Custom software, each company and university developed its software as needed
Commercial off the shelf (COTS), companies created proprietary software protected by license
Software as a Service (Saas), software moved to the cloud, and companies offering it as a service to their customers
Commercial open source software (COSS), is the latest evolution of software, where projects are developed open source but the company also offers cloud solutions (Saas or Pass) for a fee, support, and training (3).

Market

The open source market is growing year by year. More companies are creating their business around open source, and more and more investors are investing capital in open companies.

The business of an open company can be different from each other, some companies make money on support, others on a hosted service (SaaS or PaaS), still others use restrictive licenses for commercial use, and finally some offer their core business in open mode but put additional features for a fee (4)

In recent years there has been an increase of companies with an open approach to increasingly increase the interest of investors (5), the list of companies that have raised funds or have made IPOs is long, we can mention Red Hat which can be considered the progenitor. We can name HashiCorp, MongoDB, Gitlab, Docker which completely revolutionized the tech world, CoreOS, Mozilla, Apache. I could go on for a long time, but the point is that everyday companies whether they are giants or startups are producing open source software.

It is wrong to think that open source means free!

Unfortunately, there is still the idea that open is synonymous with free and that companies that base their business on open source are crazy, but there is no more wrong in thinking that way. An open source project can also be a business project (6), like any project that aims to sell it has to answer specific questions and requirements:

What is your community?
Who are your users?
Who are your buyers?
How does your software offer a solution by solving the problem?

Once you have answered these questions you need to focus on three key aspects:

Adaptation to the community, interaction from developers to the project must be moderated and solicited. It is assessed by the number of stars, pr, issues, etc...
Adaptation to the product market, adoption by users whether they are tech or not, the product must solve needs and adapt to demands. It can be assessed by downloads or uses
Adaptation to market value, the creation of value based on buyers' interests. It is measured by revenue

Pro e Contro

The open source approach benefits everyone, without having to repeat the usual things, open code is more maintainable, it is more secure, it is more scalable, and above all, it is useful to the community which in my opinion is the most important thing.

The philosophy of freedom of use is what is allowing information science to evolve day by day.

The mere fact that millions of people are working on a single project producing secure and reliable software suggests that this approach is the right one.
If we think about PyTorch which a few weeks ago was donated to the Linux Foundation by Meta to make it independent of the corporate vision so that the project can be carried on in total transparency by the community.

Of course, there are downsides to this as well, to make a project open it is not enough to just throw the code on GitHub, that is the first step! To make a project open -in my opinion- you need a vision of the problem the project is going to solve, once you have a clear idea, you need to publish the code of course, but with caveats:

Need a user guide for the use
Need a guideline and/or procedures for development
Need to outline the rules for the integration of code (Pull Request / Merge Request) by the community
Need a code of conduct
Need to choose the right license for the project and the business idea you want to pursue

These are the first mandatory steps to consider an "open source" project, then there are other aspects and difficulties in running an open project:

Coordinating implementations and tasks efficiently, while managing to maintain a balance between business and community needs
Managing pr/mr by carefully reviewing code and running automated tests for errors
Transparency, you need to engage the community by giving a clear view of the development and release timeline
Pay close attention to security issues not only of the code itself but also of installed dependencies
Use libraries that are compatible with your license

The open source world is the present and the future for software, it is all very well, but it has its difficulties that one must pay attention to.

Project

With the Italia Opensource project, we are trying to shake up the Italian tech ecosystem, our goal can be divided into two:

The first is to give visibility to open source projects developed by Italian companies and/or developers.
The second is to give 360-degree visibility to the Italian tech world through open data that provides information about companies, startups, scale-up, incubators, accelerators, events, and more.

The Italy Opensource project is on GitHub and everyone can contribute to add data and information through pr, we are still at the beginning but it is the community response has been strong and in a few weeks we already have many contributors.

https://github.com/italia-opensource

Considerations

I have not spoken to you with numbers, those you can very well find in the resources listed below, mine is meant to be an article to start a debate, spark a discussion, and make it clear that the tech world is going in that direction.

It will surely evolve further in the future, maybe there will be a way to reward open library creators according to usage, maybe ads will be introduced, or maybe there will be a way to reward contributors according to their contributions.

I want to leave you with provocation. We complain that the Italian and European tech ecosystem lags behind the American one, which is true if we consider the degree of digital illiteracy and technologies used (by tech and non-tech companies).
So I ask you how many tech companies in Italy and Europe base their business on the open model?
How many companies contribute to open source projects?

I have my answers, I leave yours to you (in case let me know in the comments).

Ref

Resources

https://pimcore.com/en/why-open-source

https://www.zdnet.com/article/its-an-open-source-world-78-percent-of-companies-run-open-source-software/

https://www.codemag.com/Article/2009041/When-Open-Source-Came-to-Microsoft

https://linuxfoundation.org/wp-content/uploads/LFResearch_Harvard_Census_II.pdf

https://www.linuxfoundation.org/wp-content/uploads/2020FOSSContributorSurveyReport_121020.pdf

https://www.synopsys.com/content/dam/synopsys/sig-assets/reports/rep-ossra-2022.pdf

IaC management on AWS cloud environment with CDK (pt. 1)

Fabrizio Cafolla — Mon, 01 Aug 2022 20:42:00 +0000

IaC management on AWS cloud environment with CDK (pt. 1)

Overview

The concept for this series of articles is to explain what and how the CDK framework interacts with AWS to create cloud infrastructure.
The series will be split into three articles:

The first -this one- will introduce the logic of the framework and its steps, starting with getting hands-on with the code.
The second article will address the management of IAM permissions and CI/CD pipelines on Github.
The third article is the implementation of a small project that will cover the use of some AWS services

The language of reference will be Python.

Introduction to aws cdk

Cloud Development Kit (aka CDK) è un framework con il quale si definisce l'infrastruttura che dovrà essere creata su AWS.

The AWS CDK lets you build reliable, scalable, cost-effective applications in the cloud with the considerable expressive power of a programming language.
- Official docs

Currently the supported languages are Typescript, Python, Go, C#, and Java. The definition of the infrastructure then is done through programming languages that allow for greater flexibility and maintainability than Cloudformation, as well as the fact that it is not necessary to learn new semantics, but rather it is enough to know a language and the aws_cdk libraries/API. The output of CDK is a Cloudformation file that can be used to deploy your infrastructure.

CDK is a framework that allows the creation of infrastructure exclusively on AWS, making it locked to a single vendor; however, there are alternatives such as Pulumi or Terraform, which give the ability to interface across multiple providers. What you recommend then is to evaluate well the purpose and goals of your cloud structure. Although I think that multi-cloud makes sense in a few business contexts.

To elaborate further, there are also two other CDK frameworks:

cdk8s that allows manifest definition using programming languages so that .yml or Helm files are avoided
cdktf which wraps terraform allowing infrastructure definition using a language (Still not very mature)
## How it works?

CDK can be divided into three distinct phases, bootstrap, synth, and deployment, let's look at them in detail:

bootstrap is the phase in which the deployed code is executed generating the Cloudformation Toolkit template as output. In practice, it connects to AWS using the profile, account, and region chosen. It will then go on to create a stack that will lay out the basic resources for the CDK environment, i.e., an S3 bucket containing the Cloudformation infrastructure files, IAM roles to run the stacks, SSM parameter for versioning, and ECR.
synth is the phase where the defined code is translated into Cloudformation files, by default it is written to the cdk.out folder.
deploy in this phase the infrastructure stack is created and deployed using the files in cdk.out. The provisioning of required resources may vary by service, in output, all progress is shown

The concept behind CDK is that by using one programming language among those supported it is possible to implement the AWS infrastructure for your services, as seen above it is divided into several phases, and it is possible to manage each phase separately thus having full control over provisioning.
The versatility of CDK allows you to define multiple stacks in the same repository and manage their deployment separately and independently, so there are three key files to consider:

cdk.json is the configuration file where the application to be used when running the CLI cdk commands in the repository and other settings are defined. For a more in-depth.
app.py (the counterpart of cdk.ts in Typescript) is the entry point of our infrastructure in this file the stacks are declared, each stack can be deployed autonomously and independently through the CLI, and it can also contain security logic such as region constraints on which to provisioning.
stack.py (the name may change depending on how you ran the CDK init command) is the file where the infrastructure will be defined using the constructs and classes for the services you want to use

The other concepts regarding cdk's application logic you can learn more about in the official documentation

Review

To recap we have our repository containing configuration files, dependencies, and one or more stack files.
Each stack file defines the services to be created, specifically, each stack class uses modules for each service it is intended to implement. The modules contain the service constructors, which can be of two types:

L1 which is exactly how the resources defined by Cloduformation are.
L2 are constructs that extend the base class Construct and define a set of methods and properties to interact with the resource. You can then manipulate the resource or pass it to other constructs so that you can define connections, example grant permissions.

Hands-on

Our goal is to create the infrastructure with CDK.
You can clone the project related to this series from then
https://github.com/FabrizioCafolla/cdk-demo or follow the following steps by hand:

Install cdk

npm install -g aws-cdk

Create repository

export APPNAME="cdk-demo"
mkdir ${APPNAME}
cd ${APPNAME}

cdk init app --language=python

code . # if use vscode

Now we can implement the stack in cdk_demo/cdk_demo_stack.py (if you used the same APPNAME). Let's create a simple S3 bucket:

import os

from aws_cdk import Stack
from aws_cdk import aws_s3 as s3
from constructs import Construct


class CdkDemoStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        self.stage = os.environ['ENVIRONMENT']

        s3.Bucket(
            self,
            'DemoBucket',
            bucket_name=f'demo-{self.environment.account}-{self.stage}-{self.environment.region}',
        )

Now we define the stack in the app.py file

#!/usr/bin/env python3
import os

import aws_cdk as cdk

from cdk_demo.cdk_demo_stack import CdkDemoStack

app = cdk.App()

region = os.getenv('CDK_DEFAULT_REGION')
account_id = os.getenv('CDK_DEFAULT_ACCOUNT')

if region not in ['eu-west-1']:
    raise Exception(f'CDK_DEFAULT_REGION must be eu-west-1, but is: {region}')

if os.getenv('ENVIRONMENT') is None:
    raise Exception(f'var ENVIRONMENT is not set')

environment = cdk.Environment(account=account_id, region=region)

CdkDemoStack(
    app,
    construct_id='CdkDemoStack',
    stack_name='CdkDemoStack',
    description='Demo stack with cdk',
    env=environment,
    synthesizer=cdk.DefaultStackSynthesizer(
        qualifier='demo',
        file_assets_bucket_name=f'{account_id}-cdk-demo-toolkit',
    )
)

app.synth()

In this case we defined constraints on the region, and set the Synthesizer defining which bucket to fetch Cloudformation files from. Of defualt the synthesizer parameter can be non-passed but only in case the --toolkit-bucket-name option was not used at bootstrap, which allows you to choose a name instead of letting it be defined automatically

Now that we have defined the stack and constructs to create an s3 bucket we can deploy the infrastructure

export AWS_PROFILE=name-of-aws-profile      # req. | or export aws credentials
export AWS_ACCOUNT_ID=aws-account-id        # req. 
export AWS_REGION=region-name               # if profile has default region, this line is not needed
export ENVIRONMENT=staging|qa|production    # if you need inside the stack to know the environment  

# Create CdkDemoToolkit stack on Cloudformation
cdk bootstrap --toolkit-stack-name CdkDemoToolkit --toolkit-bucket-name ${AWS_ACCOUNT_ID}-cdk-demo-toolkit --qualifier demo

# Create cdk.out folder with templates
cdk synth CdkDemoStack

# Upload templete on ${AWS_ACCOUNT_ID}-cdk-demo-toolkit bucket and deploy stack 
cdk deploy CdkDemoStack

Delete stack

cdk destroy CdkDemoStack

Notice well how in step 3 resources are defined through L2 constructs (in this case an S3 bucket) while in step 4 stacks are implemented (in this case CdkDemoStack).

Best Practices

There are some of the best practices that should be followed to have more control over the infrastructure:

Separate the logic carefully from the logic of the Constructs from the Stacks, and make the constructs agnostic, so that they can be instantiated in multiple tasks if needed
Separate Stacks only if necessary, it is recommended to separate them in case of stateful stacks and stateless stacks, for example, separate DB or S3 from the application stack.
Assign Tags to created resources, beware that by default CDK adds tags, if they conflict CDK will fail
Try to omit names to resources as much as possible so that they are gender by CDK, this improves management as it avoids name conflicts.
Avoid using Conditions and Parameters constructs, but use the programming language for handling parameters and conditions
Set when needed outputs and possibly export them for use in other stacks
Test the infrastructure using unit tests
Avoid using environment variables in constructs or stacks
Use roles with permissions that are consistent with the infrastructure you create so you don't give too much power during deployment

Considerations

Creating the infrastructure directly on Cloudformation is now ever discouraged, as it is not very maintainable, but more importantly, it requires knowledge of a syntax that is not exactly easy (enough on yaml or json), so it is recommended to use CDK.
Another consideration is that as much as CDK is tied to AWS, the fact that it is written in a programming language then allows for integration with Pulumi or Terraform (if using cdktf) with the respective language, so that they can work in synergy.
The CDK community is very active, mainly because you will see tutorials or other things based on Typescript, but the constructs are the same for all supported languages.
The following site constructs offers basic constructs/snippets to implement your services.

Resources

https://docs.aws.amazon.com/cdk/v2/guide/home.html

https://docs.aws.amazon.com/cdk/api/v2/

https://www.pulumi.com/docs/intro/vs/cloud-template-transpilers/aws-cdk/

https://medium.com/codex/points-to-consider-for-structuring-infrastructure-as-code-repositories-886ff58404b8

https://reflectoring.io/getting-started-with-aws-cdk/

https://docs.aws.amazon.com/it_it/cdk/v2/guide/best-practices.html

Deploy article with GitHub workflow on dev.to and medium.com

Fabrizio Cafolla — Tue, 10 May 2022 18:32:50 +0000

Deploy article with GitHub workflow on dev.to and medium.com

Intro

This article was born from the laziness that usually surrounds us, programmers.

Let's be clear, it's constructive laziness, where the core concept is:

If you have to do it more than once automate the process...

My need is to be able to write an article in the fastest and easiest way, but also be replicable on multiple platforms.
So I started looking for a way that using a Markdown file containing the article I could publish it on dev.to and medium.com.

Fortunately, as often happens, someone thought of it before me and implemented a solution.
The beauty of open source!

https://github.com/protiumx/blogpub/tree/v0.4.1

Implementation

You can look at the repository containing the sources of the articles

https://github.com/FabrizioCafolla/blog

The structure is very simple inside the blog folder there are all my articles written with .md extension, for example:

    ---
    title: "Example"
    description: "Exmpale desc. "
    tags: tag1, tag2, tag3, tag4, tag5
    ---

    # Title

    Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.

    ![image](https://raw.githubusercontent.com/FabrizioCafolla/blog/main/posts/001/images/img.png) ==> ![image](https://raw.githubusercontent.com/<owner>/<repo>/<articles_folder>/images/img.png)

Remember inside the file you need the header (for more info see here) then you can use all the features of the markdown including the images, which in case they refer to an image in the repository, will be rendered as in the example

Now to have the articles deployed with pipeline on both platforms you have to create the file inside your repository in the following path .github/workflows, the name of the file is indifferent, and inside it you have to insert:

name: Publish articles

on:
  push:
    branches: [main]

jobs:
  publish:
    name: Publish blog
    runs-on: ubuntu-20.04   
    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Deploy
        uses: protiumx/blogpub@v0.4.1
        with:
          articles_folder: %PATH%
          devto_api_key: $
          gh_token: $
          medium_token: $
          medium_user_id: $

Note well to insert instead of %PATH% the path where the articles are contained, in my case is simply posts

Once you have created and uploaded your repository on GitHub you have to insert the secrets so that the pipeline can connect to the API of the platforms. Then enter the following keys:

DEVTO_TOKEN: generate token on dev.to
MEDIUM_TOKEN: generate token on medium
MEDIUM_ID: get user id medium from API

Once you have inserted the secrets and written the articles the deployment pipeline will be executed only by main you can change it to your liking.

Considerations

The first consideration is that I still don't understand well how the update of the articles works in case of modification after the publication.

A second consideration is that using this process from a single source I can publish on multiple platforms simply and effortlessly, if one day I wanted to publish on other sites I would just change the pipeline.