DEV Community: CHANTSZCHEUK

My Journey Learning Artificial Intelligence - Day 15

CHANTSZCHEUK — Tue, 03 Sep 2024 12:04:29 +0000

Today, we focused on implementing the AI-driven resume parsing feature. We used spaCy for named entity recognition (NER) to extract key information from resumes.

First, we installed spaCy and downloaded the English language model:

pip install spacy
python -m spacy download en_core_web_sm
Then, we created a new service for resume parsing:

# app/services/resume_parser.py
import spacy

nlp = spacy.load("en_core_web_sm")

def parse_resume(text):
    doc = nlp(text)

    parsed_data = {
        "name": [],
        "email": [],
        "phone": [],
        "skills": [],
        "education": [],
        "experience": []
    }

    for ent in doc.ents:
        if ent.label_ == "PERSON":
            parsed_data["name"].append(ent.text)
        elif ent.label_ == "EMAIL":
            parsed_data["email"].append(ent.text)
        # Add more entity extractions here

    # Custom skill extraction (simplified)
    skill_keywords = ["Python", "JavaScript", "Machine Learning", "Data Analysis"]
    parsed_data["skills"] = [keyword for keyword in skill_keywords if keyword.lower() in text.lower()]

    return parsed_data
We also created a new route to handle resume uploads:

# app/routes/resume.py
from flask import Blueprint, request, jsonify
from app.services.resume_parser import parse_resume

resume_bp = Blueprint('resume', __name__)

@resume_bp.route('/upload', methods=['POST'])
def upload_resume():
    if 'file' not in request.files:
        return jsonify({"error": "No file part"}), 400

    file = request.files['file']
    if file.filename == '':
        return jsonify({"error": "No selected file"}), 400

    if file:
        # Read the file content
        resume_text = file.read().decode('utf-8')

        # Parse the resume
        parsed_data = parse_resume(resume_text)

        return jsonify(parsed_data), 200

This is a basic implementation and will need further refinement, but it's a good starting point. Tomorrow, we'll work on improving the parsing accuracy and handling different resume formats.

My Journey Learning Artificial Intelligence - Day 14

CHANTSZCHEUK — Tue, 03 Sep 2024 12:03:07 +0000

Today marked the beginning of our ambitious AI-powered job-seeking platform project. We started by outlining the core features:

AI-driven resume parsing and analysis
Job recommendation engine
Automated skill matching
Chatbot for user assistance
We set up our development environment, choosing Python for backend development with Flask as our web framework. For the AI components, we decided to use TensorFlow and spaCy for natural language processing tasks.

Here's our initial project structure:
job_seeker_ai/
├── app/
│ ├── init.py
│ ├── models/
│ ├── routes/
│ ├── services/
│ └── utils/
├── config.py
├── requirements.txt
└── run.py
We ended the day by setting up a basic Flask application and creating our first route:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Welcome to AI JobSeeker"

if __name__ == '__main__':
    app.run(debug=True)

Tomorrow, we'll start implementing the resume parsing featu

My Journey Learning Artificial Intelligence - Day 11

CHANTSZCHEUK — Tue, 03 Sep 2024 12:01:23 +0000

Today marked a significant milestone in my AI learning journey as I completed Microsoft's comprehensive course on Generative AI. This intensive program provided a deep dive into the cutting-edge world of generative models and their applications.

The course started with an introduction to the fundamental concepts of Generative AI, including the architecture of generative models, particularly focusing on transformer-based models like GPT (Generative Pre-trained Transformer). I learned about the self-attention mechanism, which is crucial for these models to understand context in sequences of data.

One of the most interesting parts was learning about prompt engineering. I now understand how to craft effective prompts to guide AI models in generating desired outputs, whether it's for text completion, summarization, or even code generation. This skill feels like a superpower, allowing me to communicate more effectively with AI systems.

The course also covered ethical considerations in AI, emphasizing the importance of responsible AI development. We discussed potential biases in training data and how they can affect model outputs, as well as strategies to mitigate these issues.

Practical sessions included hands-on experience with Azure OpenAI Service. I learned how to set up the service, make API calls, and integrate generative AI capabilities into applications.

My Journey Learning Artificial Intelligence - Day 10

CHANTSZCHEUK — Tue, 03 Sep 2024 11:58:50 +0000

Today I dived into recommendation systems. I learned about collaborative filtering, content-based filtering, and hybrid approaches. Using the Surprise library, I implemented a simple movie recommendation system based on user ratings.

I was intrigued by how these systems can personalize user experiences across various platforms, from e-commerce to streaming services.

from surprise import Dataset, Reader, SVD
from surprise.model_selection import train_test_split
from surprise import accuracy

# Load the movielens-100k dataset
data = Dataset.load_builtin('ml-100k')

# Split the data into training and testing sets
trainset, testset = train_test_split(data, test_size=.25)

# Use SVD algorithm
algo = SVD()

# Train the algorithm on the trainset
algo.fit(trainset)

# Predict ratings for the testset
predictions = algo.test(testset)

# Compute and print Root Mean Squared Error
rmse = accuracy.rmse(predictions)
print(f'RMSE: {rmse}')

# Make recommendations for a specific user
user_id = 196  # example user id
item_id = 302  # example item id
pred = algo.predict(user_id, item_id)
print(f'Predicted rating for user {user_id} on item {item_id}: {pred.est}')

My Journey Learning Artificial Intelligence - Day 8

CHANTSZCHEUK — Tue, 03 Sep 2024 11:57:16 +0000

Explored the ethical implications of AI today. I learned about bias in AI systems, the importance of fairness in machine learning models, and the potential societal impacts of AI. I also studied some case studies of AI ethics failures and how they could have been prevented.

This day made me realize the crucial role of responsible AI development and the need for diverse perspectives in the field.

My Journey Learning Artificial Intelligence - Day 6

CHANTSZCHEUK — Tue, 03 Sep 2024 11:55:04 +0000

Today was all about working with APIs. I learned how to integrate AI services into applications using APIs. I used the OpenAI API to generate text completions and the Google Cloud Vision API for image analysis.

This hands-on experience showed me how powerful pre-built AI services can be, allowing developers to add AI capabilities to their applications without building models from scratch.

import openai

# Set up your API key
openai.api_key = 'your-api-key-here'

def generate_text(prompt):
    response = openai.Completion.create(
      engine="text-davinci-002",
      prompt=prompt,
      max_tokens=100
    )
    return response.choices[0].text.strip()

# Example usage
prompt = "Write a short story about a robot learning to paint:"
generated_text = generate_text(prompt)
print(generated_text)

My Journey Learning Artificial Intelligence - Day 5

CHANTSZCHEUK — Tue, 03 Sep 2024 11:52:06 +0000

My Journey Learning Artificial Intelligence - Day 5

Today was all about natural language processing (NLP). I learned about tokenization, stemming, and lemmatization as fundamental text preprocessing steps.

I also explored word embeddings, and how they capture semantic relationships between words in a vector space.

My Journey Learning Artificial Intelligence - Day 4

CHANTSZCHEUK — Tue, 03 Sep 2024 11:49:46 +0000

Today I explored supervised learning, a fundamental concept in machine learning. Supervised learning involves training models on labeled data to make predictions or classifications. I learned about two main types: regression for predicting continuous values, and classification for categorizing data into discrete classes.

My Journey Learning Artificial Intelligence - Day 3

CHANTSZCHEUK — Tue, 03 Sep 2024 11:45:56 +0000

Today, I delved into the fascinating world of neural networks, the backbone of many AI systems. Neural networks are inspired by the human brain's structure and function, consisting of interconnected nodes or "neurons" that process and transmit information.

I learned about the basic components of a neural network: input layer, hidden layers, and output layer.

Each connection between neurons has a weight, which is adjusted during the learning process. The key to a neural network's ability to learn lies in its activation functions and the process of backpropagation.

Activation functions introduce non-linearity into the network, allowing it to learn complex patterns. Common activation functions include ReLU (Rectified Linear Unit), Sigmoid, and Tanh. Backpropagation is the algorithm used to calculate gradients and update weights, enabling the network to minimize errors and improve its predictions.

I also explored different types of neural networks, such as Convolutional Neural Networks (CNNs) for image processing and Recurrent Neural Networks (RNNs) for sequential data like text or time series.

The concept of deep learning, which involves neural networks with many hidden layers, particularly intrigued me. It's amazing how these deep networks can automatically learn hierarchical representations of data, leading to breakthroughs in various fields like computer vision and natural language processing.

My Journey Learning Artificial Intelligence -Day2

CHANTSZCHEUK — Fri, 02 Aug 2024 11:22:50 +0000

First time try Azure OpenAI to make API call on python

create new deployment in Azure OpenAI Studio and set up deploy model to make API calls.

It need to install the necessary libraries and run the following command in cmd.
pip install -r requirements.txt

Create .env file for API Keys.

_A .env file is used to store environment variables, which can be accessed by your application to keep sensitive information like API keys secure and out of your source code. _

Try to run the ValidateSetup.py

There have a error about rate limit, the reason about this problem is because of Azure Student Account Quotas has limit 1000 tokens.

Luckily ,I find a free API Key on GitHub and active successfully

My Journey Learning Artificial Intelligence -Day1

CHANTSZCHEUK — Thu, 01 Aug 2024 17:18:07 +0000

The term "Artificial Intelligence" (AI) has become increasingly popular in recent years. Whether in the tech industry, business sector, or everyday life, its presence is ubiquitous. As a student currently studying AI, I would like to share some experiences and the key point from this journey.

Foundation Models versus LLMs

The term Foundation Model was coined by Stanford researchers and defined as an AI model that follows some criteria, such as:

They are trained using unsupervised learning or self-supervised learning, meaning they are trained on unlabeled multi-modal data, and they do not require human annotation or labeling of data for their training process.
They are very large models, based on very deep neural networks trained on billions of parameters.
They are normally intended to serve as a ‘foundation’ for other models, meaning they can be used as a starting point for other models to be built on top of, which can be done by fine-tuning.

Large Language Models (LLMs)

Based on Transformer architecture, trained on vast amounts of unlabeled data.
Capable of generating grammatically correct and creative text responses.
Work with numerical tokens for better performance.

How Large Language Models Work

Tokenization: Process text inputs into numerical tokens.
Prediction: Model predicts output tokens based on input tokens.
Selection: Outputs tokens based on probability distribution, introducing randomness for creativity.
Tuning: Model parameter like temperature controls the randomness level.

Thanks for this youtube video by 3Blue1Brown who help me a lot.