Forem: Mujahida Joynab

Network Address Translation

Mujahida Joynab — Fri, 10 Apr 2026 05:33:55 +0000

NET is used due to insufficient number of IPv4 address for all internet connected device .
How NAT Works

NAT usually lives inside your Router. Here is how it handles your data:
The Request: You sit at your laptop (Private IP: 192.168.1.5) and request to see google.com.
The Translation: Your router receives this request. It knows 192.168.1.5 cannot travel on the public internet. It "translates" your private address into the router's Public IP (e.g., 203.0.113.10).
The Table: The router makes a note in its NAT Translation Table. It records which private device requested which website and through which "Port."
The Response: Google sends the data back to your Public IP. The router checks its table, sees the data is meant for your laptop, and passes it back to 192.168.1.5.

Types of NAT
There are three main ways NAT is implemented:
Static NAT: Maps one private IP to one public IP. Usually used for servers inside a network that need to be accessed from the outside.
Dynamic NAT: Maps a private IP to a public IP from a group (pool) of available public IPs.
PAT (Port Address Translation): Also known as NAT Overload. This is what you use at home! It allows thousands of devices to share one public IP by assigning each device a unique "Port Number."

The Benefits of NAT
IP Conservation: We don't need a unique public IP for every single smartphone and tablet on Earth.
Security: NAT acts as a natural firewall. Since your private IP is hidden, hackers on the internet cannot see your device directly; they only see your router's public address.
Flexibility: You can change your internal network setup (add or remove devices) without having to request new IP addresses from your ISP.

Private IP Addresses

Mujahida Joynab — Fri, 10 Apr 2026 01:39:57 +0000

Private IP address are unique within a Local Area Network . It can connected through router using Network Address Translation(NAT) . Private IP addresses range
10.0.0.0 - 10.255.255.255 ; which is class A
172.16.0.0 - 172.31.255.255 ; which is class B
192.168.0.0 - 192.168.255.255 ; which is class C

Subnet mask

Mujahida Joynab — Mon, 02 Mar 2026 14:58:44 +0000

We understand by subnet mask that which bits are fixed and which bits are changeable (host portion).
Example - 192.168.1.0/24
Here first 24 bits are fixed .
Total Bit = 32
Rest = 32 - 24 = 8
and 2^8 - 2 = 254 are changable

Why 2 are subtracted ?
Because 0 and 255 are researved

0 = Network Address (Reserved )(All host bit 0)
Example: 192.168.1.0

255= Broadcast Address (All host bit 1)
Example: 192.168.1.255

Usable IP range: 192.168.1.1 to 192.168.1.254 (254 addresses)

Rectified Linear Unit

Mujahida Joynab — Fri, 13 Feb 2026 14:57:29 +0000

ReLU is the most popular activation function in deep learning because it’s super simple and makes AI learn much faster.

What it does (main point):

Positive input? → Passes it exactly as is to the next layer
Negative or zero input? → Outputs 0 (blocks it, nothing passes)

ReLU(x) = max(0, x)

Why this makes AI learn fast:

No "squashing" like old functions (Sigmoid/Tanh) → gradients don’t vanish
Very fast to compute (just check if > 0)
Many neurons turn off (output 0) → less work, faster training

Quick comparison:

Sigmoid → slow, vanishing gradient
Tanh → better but still slow
ReLU → fast, no vanishing gradient (for positive values)

That's why almost every modern neural network (CNNs, Transformers, etc.) uses ReLU by default.

One small issue: Sometimes neurons "die" (always output 0 and stop learning).

Solution: Use Leaky ReLU or similar if needed.

Main thing in one line:

ReLU lets only positive signals pass through fully and blocks negative ones → this simple rule makes deep learning train fast and powerful.

Softmax Function

Mujahida Joynab — Fri, 13 Feb 2026 14:06:41 +0000

Softmax = a simple trick that turns scores into probabilities (numbers between 0 and 1 that add up to exactly 1).

Imagine you are waiting for Bus 49 and want to guess:

Will there be lots of empty seats?
Will there be only a few empty seats?
Will there be no empty seats at all?

We give each situation a “happiness score”:

Lots of empty seats → score 3 (yay! ❤️)
Few empty seats → score 2 (okay 😐)
No empty seats → score 1 (ugh 😩)

Now softmax magic happens in just two steps:

Step 1: Make each score much bigger using exponential (e^score). This makes good things really stand out!

e³ ≈ 20
e² ≈ 7
e¹ ≈ 3

(We use easy round numbers here — actual values are 20.1, 7.4, 2.7, but close enough!)

Step 2: Add them up and divide to get probabilities.

Total = 20 + 7 + 3 = 30

Now the chances are:

Lots of empty seats → 20 / 30 = ⅔ ≈ 67%
Few empty seats → 7 / 30 ≈ 23%
No empty seats → 3 / 30 = 10%

→ 67% + 23% + 10% = 100% ✓

That’s it! Softmax just says:

“Turn your scores into chances — the better score gets much more chance, but everyone still gets something, and it all adds to 100%.”

The Tiny Formula (you can almost remember it)

For any score z:

probability = eᶻ / (sum of e for all scores)

That’s why in apps, games, or AI models (like ChatGPT choosing the next word), the final answer often comes from softmax — it picks the most likely thing, but softly, with percentages.

What is an Expert System?

Mujahida Joynab — Sat, 13 Dec 2025 05:50:51 +0000

Imagine you have a super-smart robot doctor inside a computer. That's kind of what an Expert System is! It's a computer program that knows a lot about something special and can help make decisions—just like a human expert would.

🧠 How Does It Work? Think of It Like This:

An Expert System has two main parts:

1. The Knowledge Base - The "Brain Library" 📚

This is where all the expert knowledge is stored!

Facts: Simple truths like:
- "My temperature is 103°F" 🌡️
- "I have a headache" 🤕
Rules: "If-Then" instructions that connect facts, like:
- IF temperature > 100°F AND headache = yes
- THEN disease might be fever

2. The Inference Engine - The "Thinking Machine" ⚙️

This is the problem-solver that uses the knowledge base to figure things out! It works in two cool ways:

🔍 Forward Chaining: Starting with facts to reach a conclusion

Facts → "I have high temperature" + "I have headache"
        ↓
    Thinking... 🤔
        ↓
Conclusion → "You might have fever!"

🔍 Backward Chaining: Starting with a goal and checking facts

Goal → "Do I have fever?"
        ↓
    What facts do I need? 🤔
        ↓
Check → Do I have high temperature? Yes!
        Do I have headache? Yes!
        ↓
Conclusion → "Yes, you might have fever!"

🌟 Real-Life Examples You Might Know:

Medical Help: Some computer programs help doctors figure out what illness you might have.

Farm Help: Programs that help farmers know when to water plants or what fertilizer to use.

🛠️ How Do People Make Expert Systems?

Expert System Shells: These are like ready-made toolkits! Programmers add the specific knowledge they need. Some popular ones are:

CLIPS
Jess

📝 Three Main Ways to Store Knowledge:

If-Then Rules: Like a recipe book of decisions
Decision Trees: Like a choose-your-own-adventure book
Frames: Like organized file folders with information

🔍 Why Are They So Careful?

Good expert systems include:

Validation: Making sure the information is correct ✅
Explanation: Being able to explain why they made a decision (Example: "I think you have fever because your temperature is high and you have a headache")
Data Sensitivity: Being careful with private information 🔒

💡 Fun Fact:

There's an expert system called PITUMBERG (you might have meant "PITUBERG" or similar) that shows how these systems can help in specific fields!

✨ In a Nutshell:

Expert Systems = Knowledge Base (what it knows) + Inference Engine (how it thinks)

They help doctors, farmers, engineers, and many others make smart decisions by combining lots of knowledge with logical rules—just like a very helpful robot friend! 🤖💖

Next time you play a detective game or solve a puzzle, remember—you're thinking a bit like an expert system too!

A Complete Guide to Evidence Fusion and Risk Assessment Using Sequential Combination

Mujahida Joynab — Sat, 13 Dec 2025 05:21:55 +0000

Introduction

In decision-making systems, particularly in risk assessment and analysis, we often face the challenge of combining multiple pieces of evidence into a unified perspective. This blog explores an elegant sequential combination method for fusing evidence values (like 100, 1000, or any number of inputs) to determine risk probabilities across multiple categories—from "Very Very Low" to "Very Very High" risk.

The Core Methodology: Sequential Evidence Fusion

The Sequential Combination Formula

The heart of our approach lies in sequentially combining evidence using a weighted fusion method:

Start with the first two evidence values (m₁ and m₂)
Combine them into a single value (C₁)
Take this combined value and fuse it with the third evidence (m₃) to get C₂
Continue this process: Cₙ = fuse(Cₙ₋₁, mₙ₊₁)
Repeat until all evidence is incorporated

This incremental approach allows the system to naturally weigh evidence as it accumulates, creating a dynamic assessment that evolves with each new piece of information.

Mathematical Foundation

The combination formula typically follows a pattern that might look like:

C_k = α·C_{k-1} + β·m_k + γ·(C_{k-1}·m_k)

Where coefficients α, β, and γ are tuned based on:

Evidence reliability
Temporal relevance (if evidence is time-stamped)
Domain-specific importance factors

Normalization: The 1-k Factor

After sequential combination, we apply normalization to ensure our final value falls within a consistent range (typically 0 to 1):

Normalized Value = 1 - k · (some transformation of combined evidence)

Or more generally:

Normalized Score = 1 - f(combined_evidence)

This normalization ensures that higher combined evidence values correspond to higher risk levels, properly scaled for interpretation.

Risk Categorization Framework

Our system classifies risk into 11 distinct categories for granular assessment:

Risk Level	Typical Probability Range	Description
Very Very Low	0-9%	Minimal to negligible risk
Very Low	10-19%	Low probability of adverse outcomes
Low	20-29%	Below average risk
Very Very Medium	30-39%	Lower medium risk
Very Medium	40-49%	Medium-low risk
Medium	50-59%	Average/expected risk level
High Medium	60-69%	Medium-high risk
High	70-79%	Elevated risk requiring attention
Very High	80-89%	Significantly elevated risk
Very Very High	90-100%	Critical risk requiring immediate action

Practical Implementation: From Excel to Actionable Insights

Step 1: Data Preparation

Evidence values stored in Excel (or CSV) format are loaded into the system. These could represent:

Financial transaction amounts
Security alert scores
Medical test results
Quality control measurements
Any numerical evidence relevant to risk assessment

Step 2: Sequential Combination Process

def sequential_combine(evidence_list, alpha=0.4, beta=0.4, gamma=0.2):
    """
    Sequentially combine evidence using weighted fusion
    """
    if len(evidence_list) < 2:
        return evidence_list[0] if evidence_list else 0

    # Normalize evidence to [0,1] range first
    normalized_evidence = [normalize(e) for e in evidence_list]

    # Start with first two pieces of evidence
    combined = alpha*normalized_evidence[0] + beta*normalized_evidence[1] + gamma*(normalized_evidence[0]*normalized_evidence[1])

    # Sequentially combine with remaining evidence
    for i in range(2, len(normalized_evidence)):
        combined = alpha*combined + beta*normalized_evidence[i] + gamma*(combined*normalized_evidence[i])

    return combined

Step 3: Risk Probability Calculation

def calculate_risk_probabilities(combined_score):
    """
    Convert combined score into risk category probabilities
    """
    # This could use a softmax distribution across categories
    # or a Bayesian approach based on historical data
    risk_categories = ["Very Very Low", "Very Low", "Low", 
                      "Very Very Medium", "Very Medium", "Medium",
                      "High Medium", "High", "Very High", "Very Very High"]

    # Generate probabilities (example using transformed sigmoid)
    base_prob = sigmoid_transform(combined_score)

    # Distribute probabilities across categories
    # (Implementation depends on specific distribution model)
    return category_probabilities

Synthetic Data Generation

For testing and validation, we can generate synthetic evidence data:

import numpy as np
import pandas as pd

def generate_synthetic_evidence(num_samples=1000, num_evidence_points=50):
    """
    Generate realistic synthetic evidence data
    """
    data = []

    for _ in range(num_samples):
        # Generate evidence with different patterns
        pattern_type = np.random.choice(['random', 'trending_up', 'trending_down', 'spiky'])

        if pattern_type == 'random':
            evidence = np.random.uniform(0, 1000, num_evidence_points)
        elif pattern_type == 'trending_up':
            base = np.random.uniform(0, 500, num_evidence_points)
            trend = np.linspace(0, 500, num_evidence_points)
            evidence = base + trend
        elif pattern_type == 'trending_down':
            base = np.random.uniform(0, 500, num_evidence_points)
            trend = np.linspace(500, 0, num_evidence_points)
            evidence = base + trend
        else:  # spiky
            evidence = np.random.exponential(200, num_evidence_points)
            spikes = np.random.choice([0, 1], num_evidence_points, p=[0.9, 0.1])
            evidence = evidence * (1 + spikes * np.random.uniform(1, 5, num_evidence_points))

        data.append(evidence)

    return pd.DataFrame(data)

Real-World Applications

1. Financial Fraud Detection

Combine multiple transaction alerts (amount, frequency, location mismatch) into a unified risk score.

2. Healthcare Diagnostics

Fuse various test results and symptoms to assess disease probability.

3. Cybersecurity Threat Assessment

Combine network anomalies, failed login attempts, and suspicious file activities into a comprehensive threat level.

4. Quality Control in Manufacturing

Fuse multiple sensor readings from production lines to predict defect probability.

Advantages of Sequential Combination

Incremental Updates: New evidence can be added without reprocessing all historical data
Computational Efficiency: O(n) complexity for n evidence points
Interpretability: Each combination step can be logged and analyzed
Adaptability: Weights can be adjusted based on evidence reliability
Memory Efficiency: Only need to store the current combined value, not all historical evidence

Challenges and Considerations

Order Sensitivity: Sequential combination may be order-dependent
Weight Calibration: Optimal α, β, γ values require careful tuning
Normalization Consistency: Ensuring consistent scaling across different evidence types
Category Thresholds: Defining clear boundaries between risk levels

Conclusion

The sequential evidence fusion approach provides a robust, scalable framework for combining thousands of evidence points into coherent risk assessments. By normalizing results and distributing probabilities across granular risk categories (from "Very Very Low" to "Very Very High"), decision-makers gain nuanced insights that support better risk management decisions.

Whether you're working with 100 or 100,000 evidence points in Excel, this methodology transforms raw data into actionable intelligence, enabling organizations to make informed decisions in uncertain environments.

Key Takeaway: The power of this approach lies not in any single piece of evidence, but in the sophisticated fusion of all available information, progressively refined through sequential combination to reveal the true underlying risk profile.

CSS

Mujahida Joynab — Sat, 22 Nov 2025 12:08:39 +0000

Font -> Google font
Icon -> Font Awesome cdn
For Responsiveness

flex-wrap : wrap

Hello Banner

Lorem ipsum

How to Identify Research Gaps

Mujahida Joynab — Mon, 10 Nov 2025 15:37:33 +0000

9 ways to identify gaps -

Look for inspiration in published literature
Find keywords and terms related to your selected topics
Seek help from your research advisor
Use digital tool to seek out popular topics or most cited research papers
- MENDELEY
- PUBMED
- SCOPUS
- PUBCRAWLER
- ZOTERO
Check the websites of influential journals 'Key concept'

Reference section of the most impactful or highly cited papers is also an important resource

Make a note of your queries Map the question to the resource Table , Chats, Pictures and other documentation topic
Research each question
Be aware of the literature gap

Expressions of gap -

needed
key question
important to address
future areas of research
Read systematic reviews

The impact of COVID-19 pandemic has been far-reaching across multiple disciplines .
What aspect of my field of study I can correlate with the pandemic ``, and the research gap I can identify ?

Reference :
https://researcheracademy.elsevier.com/research-preparation/research-design/identify-research-gaps

Top-Down and Bottom-Up Parsing

Mujahida Joynab — Mon, 03 Nov 2025 19:30:35 +0000

Top-Down Parsing (Leftmost Derivation)

The process starts with the starting symbol $$ S $$ and expands the leftmost non-terminal at each step.
Given:
- $$ S \rightarrow AB $$
- $$ A \rightarrow aA \mid \epsilon $$
- $$ B \rightarrow b \mid \epsilon $$
Target: $$ aaab $$

Step-by-step derivation:

$$ S \rightarrow AB $$
$$ AB \rightarrow aAB $$
$$ aAB \rightarrow aaAB $$
$$ aaAB \rightarrow aaaAB $$
$$ aaaAB \rightarrow aaa\epsilon B $$
$$ aaa\epsilon B \rightarrow aaab $$

This is a top-down parsing approach because it expands from the start symbol $$ S $$ and works downward, always expanding the leftmost non-terminal.

Bottom-Up Parsing (Rightmost Derivation in Reverse)

The process starts with the string of terminals $$ aaab $$ and works backward, reducing strings to non-terminals until you reach $$ S $$.
Working backward:
1. $$ aaab $$
2. $$ aaaB $$ (replace $$ b $$ with $$ B $$)
3. $$ aaaAB $$ (replace $$ \epsilon $$ with $$ A $$)
4. $$ aaAB $$ (replace $$ aA $$ with $$ A $$)
5. $$ aAB $$ (replace $$ aA $$ with $$ A $$)
6. $$ AB $$ (replace $$ aA $$ with $$ A $$)

This is a bottom-up parsing approach because it starts from the terminal string and works upward, reducing substrings to non-terminals.

Summary

Top-down parsing starts from the root ($$ S $$) and expands leftmost non-terminals.
Bottom-up parsing starts from the target string and works backward, reducing substrings to non-terminals until reaching the root.

Genetic Algorithm

Mujahida Joynab — Mon, 03 Nov 2025 19:25:23 +0000

Optimization :
Process of making something better

Set of input -> Process -> Output

Population -> Set of chromosomes
Chromosomes
Gene

1 0 1 1 0 0 0 1 1 0 -> Single chromosome

Operators -

- Selection

Concept
Initial population

Fitness Function -> Selection -> By applying fitness function .Select most promising element

Fitness Function :
The fitness function is the function you want to optimize . Function which takes the solution as input and produces the suitability of the solution as the output

Transformer

Mujahida Joynab — Sat, 27 Sep 2025 00:21:17 +0000

Neural networks have revolutionized natural language processing (NLP), but not all models are created equal. Early models like Recurrent Neural Networks (RNNs) laid the foundation, yet they struggled with crucial limitations. Then came Transformers, bringing a paradigm shift with self-attention and massive scaling.

Limitations of RNNs

RNNs process data sequentially, one word after another. While this makes sense for language, it also introduces several challenges:

🔁 Repetition of words: RNNs often generate loops or repetitive phrases.
📝 Grammatical issues: Long sentences can become incoherent.
🐌 Slow generation: Sequential processing makes them slower to train and infer compared to parallelizable models.
🧠 Limited memory: Even advanced variants like LSTM and GRU can only capture short- to mid-range dependencies in text.
📏 Difficulty with long-distance context: RNNs struggle when the meaning of a word depends on another word far back in the sequence.
⚖️ Ambiguity handling: They fail to properly disambiguate words with multiple meanings depending on context (e.g., “bank” as a riverbank vs. financial institution).

Example:
In the sentence “She saw him with a telescope”, RNNs find it hard to decide whether “with a telescope” modifies “saw” or “him.”

The Rise of Transformers

Transformers revolutionized NLP by introducing self-attention—a mechanism that allows the model to look at all words in a sentence simultaneously and capture how each relates to the others.

🔗 Self-attention: Understands relationships between words regardless of their distance in the sentence.
⚡ Parallel processing: Unlike RNNs, Transformers don’t rely on step-by-step computation, which makes training and inference much faster.
🔎 Context awareness: Can resolve ambiguous meanings by considering the entire sentence.
📈 Scalability: Modern models like GPT-3 (with 175 billion parameters—about 350 GB of weights) demonstrate the power of large-scale Transformers.

Example:

“I love apple.” → Links “I” with “love.”

“I love Apple phones.” → Recognizes that “Apple” refers to the brand, not the fruit.

“She saw him with a telescope.” → Understands that “with a telescope” could describe how she saw him or what he was holding, capturing both interpretations.

Applications of Transformer-based Models

Transformers have unlocked a wide range of applications:

✉️ Emails and Messages: More accurate, context-aware suggestions and auto-completions.
📰 Articles and Blogs: High-quality content generation.
🤖 Chatbots & Virtual Assistants: Smarter, more natural interactions.
🌐 Multi-modal Models: Vision-Language Models (VLMs) accept both text and images as input, powering tools like image captioning, visual Q&A, and more.

Pre-trained and Fine-tuned Models

Transformer models often start as pre-trained on massive text corpora, then are fine-tuned for specific tasks:

Pre-trained: General language understanding (e.g., GPT, BERT).
Fine-tuned: Task-specific, such as summarizing emails or generating marketing copy.