Upload 10 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+NIlesh_Hanotia_AI.pdf filter=lfs diff=lfs merge=lfs -text

NIlesh_Hanotia_AI.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1a0719bbefb24885a8bb1473a0e7128a12692817bf74a659a5951c7be7b1738
+size 281525

dataset.py

@@ -0,0 +1,24 @@
+import json
+from tokenizer import encode
+
+# Load full resume text
+with open("resume_text.txt", "r", encoding="utf-8") as f:
+    text = f.read()
+
+data = encode(text)
+context_length = 64
+
+def get_pairs(data, context_length):
+    pairs = []
+    for i in range(len(data) - context_length):
+        x = data[i : i + context_length]
+        y = data[i + 1 : i + context_length + 1]
+        pairs.append((x, y))
+    return pairs
+
+pairs = get_pairs(data, context_length)
+
+print(f"Total characters encoded : {len(data)}")
+print(f"Total training pairs     : {len(pairs)}")
+print(f"Sample input  : {pairs[0][0][:10]} ...")
+print(f"Sample target : {pairs[0][1][:10]} ...")

model.py

@@ -0,0 +1,43 @@
+import torch
+import torch.nn as nn
+
+vocab_size     = 80
+embed_dim      = 128
+num_heads      = 4
+num_layers     = 3
+context_length = 64
+
+class ResumeEncoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.token_emb    = nn.Embedding(vocab_size, embed_dim)
+        self.position_emb = nn.Embedding(context_length, embed_dim)
+        self.blocks = nn.Sequential(*[
+            nn.TransformerEncoderLayer(
+                d_model=embed_dim,
+                nhead=num_heads,
+                dim_feedforward=embed_dim * 4,
+                dropout=0.1,
+                batch_first=True
+            ) for _ in range(num_layers)
+        ])
+        self.output_head = nn.Linear(embed_dim, vocab_size)
+
+    def forward(self, x):
+        B, T = x.shape
+        tok = self.token_emb(x)
+        pos = self.position_emb(torch.arange(T, device=x.device))
+        x   = self.blocks(tok + pos)
+        return self.output_head(x)
+
+    def encode(self, x):
+        # Returns single vector for a sequence — used for similarity search
+        tok = self.token_emb(x)
+        pos = self.position_emb(torch.arange(x.shape[-1], device=x.device))
+        out = self.blocks(tok + pos)
+        return out.mean(dim=-2)
+
+if __name__ == "__main__":
+    model = ResumeEncoder()
+    print("Model created!")
+    print(f"Parameters: {sum(p.numel() for p in model.parameters()):,}")

pdf.py

@@ -0,0 +1,10 @@
+import pdfplumber
+
+with pdfplumber.open("NIlesh_Hanotia_AI.pdf") as pdf:
+    text = "\n".join(page.extract_text() or "" for page in pdf.pages)
+
+with open("resume_text.txt", "w", encoding="utf-8") as f:
+    f.write(text)
+
+print("resume_text.txt saved!")
+print(f"Total characters: {len(text)}")

resume_text.txt

@@ -0,0 +1,70 @@
+NILESH HANOTIA
+AI Implementation Lead | POC-to-Production Specialist | Enterprise AI Deployment
+Ahmedabad, India | +91-9925537229 | nilesh.hanotia@outlook.com
+CERTIFICATIONS
+AWS Certified AI Practitioner | Amazon Web Services
+PROFESSIONAL SUMMARY
+AI implementation leader with 7+ years driving enterprise AI deployments from first discovery call through
+production go-live. Specialise in POC design and execution, stakeholder alignment, and translating complex
+LLM/AWS architectures into measurable business outcomes. At Armakuni, serve as the bridge between technical
+delivery teams and enterprise clients — owning the full 11-stage POC lifecycle: project allocation, internal/external
+kick-offs, weekly governance, execution, testing, delivery, and path-to-production planning. Independently
+delivered 6+ AI products generating $5M+ combined revenue, with proven impact in healthcare, legal, analytics,
+and automation domains.
+CORE COMPETENCIES
+AI Implementation & POC Delivery: End-to-end POC lifecycle ownership, POC→Production roadmapping,
+enterprise AI adoption strategy, deployment governance, MVP scoping, client validation
+Technical Fluency: LLM pipelines & AI workflows, AWS services (Lambda, Bedrock, API Gateway, DynamoDB,
+CloudWatch), serverless architecture, API integrations, solution architecture collaboration, logging & observability
+(Langfuse, Langsmith)
+Stakeholder & Delivery Leadership: Executive alignment, discovery workshops, SOW-to-delivery conversion,
+weekly PSR reporting, risk & escalation management, account expansion strategy, cross-functional team
+coordination
+PROFESSIONAL EXPERIENCE
+Customer Solution Consultant (CSC) — AI Implementation — Armakuni 2025 – Present
+Own end-to-end delivery of AI POCs and rapid engagements (5–8 weeks) across enterprise clients in healthcare,
+legal, and automation sectors.
+• Drive the full 11-stage POC lifecycle: project allocation, SOW review, internal/external kick-offs, planning,
+weekly governance, execution oversight, testing & client validation, delivery, and path-to-production.
+• Convert Statements of Work into executable delivery plans with milestones, sprint cadences, RACI matrices,
+and risk registers.
+• Serve as primary bridge between developers, solution architects, DevOps, and enterprise client
+stakeholders — ensuring technical decisions align with business outcomes.
+• Lead weekly executive reporting (PSR), risk management, and scope control; escalate proactively across a
+structured L1→L3 escalation matrix.
+• Develop deep working knowledge of AWS services (Lambda, Bedrock, API Gateway, CloudWatch) and LLM
+pipeline architecture to engage credibly with both technical teams and client leadership.
+• Create and maintain technical documentation — process flows, README files, test cases — to ensure
+production readiness from day one of execution.
+• Facilitate path-to-production workshops with clients, mapping POC learnings to scalable architecture,
+compliance requirements (GDPR, HIPAA), and business value expansion plans.
+• Identify account expansion, cross-sell, and upsell opportunities, contributing to long-term Armakuni account
+growth strategy.
+AI Product & Implementation Lead — Independent Consultant 2021 – 2025
+Delivered AI products end-to-end — from problem discovery and architecture design through deployment, user
+adoption, and ongoing iteration — serving 10,000+ users across multiple industries.
+• Designed and deployed 6+ production AI systems generating $5M+ combined revenue across healthcare,
+legal, enterprise analytics, and automation domains.
+• Led full AI product lifecycle: stakeholder discovery, requirements definition, LLM workflow design, MVP
+build, UAT, and phased production rollout.
+• Reduced manual client workflows by 80–90% through targeted AI automation, directly measurable in client
+operations.
+• Translated complex enterprise business needs into implementable technical architectures — working hands-
+on across AWS, API integrations, and AI/LLM pipelines.
+• Built and validated AI products with real users, iterating rapidly based on adoption data and feedback to
+drive retention and expansion.
+• Simultaneously built independent projects including real-time trading systems on AWS (Lambda,
+DynamoDB, API Gateway, Bedrock, CloudWatch) — deepening hands-on serverless and AI infrastructure
+expertise.
+EARLIER CAREER
+Product Analyst — Cignex Datamatics 2020 – 2021
+Business Product Analyst — Cygnet Infotech 2019 – 2020
+Associate Product Manager — Aimdek Technologies 2017 – 2019
+TECHNICAL TOOLING
+Cloud & AI: AWS (Lambda, Bedrock, API Gateway, DynamoDB, CloudWatch, CloudFront, CDK) | LLM
+Pipelines | Langfuse | Langsmith
+Dev & Data: Python | SQL | APIs | Docker | Tableau | Mixpanel
+Delivery & Design: Jira | Zoho Projects | Figma | Panda.doc | Agile/Scrum
+EDUCATION
+Post Graduate Diploma in Business Administration — St. Kabir Institute
+Bachelor of Commerce — IGNOU

tokenizer.py

@@ -0,0 +1,25 @@
+import json
+
+# Load vocab
+with open("vocab.json", "r", encoding="utf-8") as f:
+    vocab = json.load(f)
+
+stoi = vocab["stoi"]
+itos = {int(k): v for k, v in vocab["itos"].items()}
+vocab_size = vocab["vocab_size"]
+
+def encode(text):
+    return [stoi[c] for c in text if c in stoi]
+
+def decode(ids):
+    return ''.join([itos[i] for i in ids])
+
+if __name__ == "__main__":
+    sample = "python developer with aws experience in ahmedabad"
+    encoded = encode(sample)
+    decoded = decode(encoded)
+
+    print(f"Sample text  : {sample}")
+    print(f"Encoded      : {encoded}")
+    print(f"Decoded back : {decoded}")
+    print(f"Vocab size   : {vocab_size}")

train.py

@@ -0,0 +1,56 @@
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+from model import ResumeEncoder
+from tokenizer import encode
+
+# Load resume text
+with open("resume_text.txt", "r", encoding="utf-8") as f:
+    text = f.read()
+
+data = encode(text)
+context_length = 64
+
+class ResumeDataset(Dataset):
+    def __init__(self, data, context_length):
+        self.data = data
+        self.context_length = context_length
+
+    def __len__(self):
+        return len(self.data) - self.context_length
+
+    def __getitem__(self, idx):
+        x = torch.tensor(self.data[idx : idx + self.context_length])
+        y = torch.tensor(self.data[idx + 1 : idx + self.context_length + 1])
+        return x, y
+
+dataset    = ResumeDataset(data, context_length)
+dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
+
+model     = ResumeEncoder()
+optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
+epochs    = 500
+
+
+for epoch in range(1, epochs + 1):
+    total_loss = 0
+    for x, y in dataloader:
+        logits = model(x)
+        B, T, C = logits.shape
+        loss = F.cross_entropy(logits.view(B*T, C), y.view(B*T))
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        total_loss += loss.item()
+
+    avg_loss = total_loss / len(dataloader)
+
+    if epoch % 10 == 0:
+        print(f"Epoch {epoch}/{epochs}  |  Loss: {avg_loss:.4f}")
+
+    if epoch % 50 == 0:
+        torch.save(model.state_dict(), f"resume_encoder_epoch{epoch}.pth")
+        print(f"  → Checkpoint saved at epoch {epoch}")
+
+torch.save(model.state_dict(), "resume_encoder.pth")
+print("Final model saved!")

vocab.json

@@ -0,0 +1,206 @@
+{
+  "stoi": {
+    " ": 0,
+    "e": 1,
+    "n": 2,
+    "t": 3,
+    "i": 4,
+    "a": 5,
+    "o": 6,
+    "r": 7,
+    "s": 8,
+    "l": 9,
+    "c": 10,
+    "d": 11,
+    "u": 12,
+    "p": 13,
+    ",": 14,
+    "m": 15,
+    "g": 16,
+    "\n": 17,
+    "h": 18,
+    "A": 19,
+    "y": 20,
+    "I": 21,
+    "v": 22,
+    "-": 23,
+    "P": 24,
+    "C": 25,
+    "k": 26,
+    "b": 27,
+    "w": 28,
+    "L": 29,
+    "f": 30,
+    "S": 31,
+    "O": 32,
+    "D": 33,
+    ".": 34,
+    "E": 35,
+    "x": 36,
+    "2": 37,
+    "|": 38,
+    "0": 39,
+    "R": 40,
+    "M": 41,
+    "\u2014": 42,
+    "W": 43,
+    "T": 44,
+    "1": 45,
+    "N": 46,
+    "B": 47,
+    "&": 48,
+    ":": 49,
+    "(": 50,
+    ")": 51,
+    "G": 52,
+    "+": 53,
+    "9": 54,
+    "5": 55,
+    "F": 56,
+    "\u2013": 57,
+    "/": 58,
+    "H": 59,
+    "U": 60,
+    "j": 61,
+    "7": 62,
+    "3": 63,
+    "6": 64,
+    "$": 65,
+    "\u2192": 66,
+    "V": 67,
+    "8": 68,
+    "q": 69,
+    "K": 70,
+    "@": 71,
+    "z": 72,
+    "Y": 73,
+    "X": 74,
+    ";": 75,
+    "%": 76,
+    "Q": 77,
+    "J": 78,
+    "Z": 79
+  },
+  "itos": {
+    "0": " ",
+    "1": "e",
+    "2": "n",
+    "3": "t",
+    "4": "i",
+    "5": "a",
+    "6": "o",
+    "7": "r",
+    "8": "s",
+    "9": "l",
+    "10": "c",
+    "11": "d",
+    "12": "u",
+    "13": "p",
+    "14": ",",
+    "15": "m",
+    "16": "g",
+    "17": "\n",
+    "18": "h",
+    "19": "A",
+    "20": "y",
+    "21": "I",
+    "22": "v",
+    "23": "-",
+    "24": "P",
+    "25": "C",
+    "26": "k",
+    "27": "b",
+    "28": "w",
+    "29": "L",
+    "30": "f",
+    "31": "S",
+    "32": "O",
+    "33": "D",
+    "34": ".",
+    "35": "E",
+    "36": "x",
+    "37": "2",
+    "38": "|",
+    "39": "0",
+    "40": "R",
+    "41": "M",
+    "42": "\u2014",
+    "43": "W",
+    "44": "T",
+    "45": "1",
+    "46": "N",
+    "47": "B",
+    "48": "&",
+    "49": ":",
+    "50": "(",
+    "51": ")",
+    "52": "G",
+    "53": "+",
+    "54": "9",
+    "55": "5",
+    "56": "F",
+    "57": "\u2013",
+    "58": "/",
+    "59": "H",
+    "60": "U",
+    "61": "j",
+    "62": "7",
+    "63": "3",
+    "64": "6",
+    "65": "$",
+    "66": "\u2192",
+    "67": "V",
+    "68": "8",
+    "69": "q",
+    "70": "K",
+    "71": "@",
+    "72": "z",
+    "73": "Y",
+    "74": "X",
+    "75": ";",
+    "76": "%",
+    "77": "Q",
+    "78": "J",
+    "79": "Z"
+  },
+  "vocab_size": 80,
+  "keywords": {
+    "skills": [
+      "python",
+      "aws",
+      "sql",
+      "docker",
+      "llm",
+      "bedrock",
+      "lambda",
+      "api",
+      "langfuse",
+      "langsmith",
+      "tableau",
+      "figma",
+      "jira",
+      "cdk"
+    ],
+    "education": [
+      "bachelor",
+      "post graduate",
+      "diploma",
+      "commerce",
+      "business administration"
+    ],
+    "experience": [
+      "7"
+    ],
+    "location": [
+      "ahmedabad",
+      "india"
+    ],
+    "roles": [
+      "ai implementation",
+      "product manager",
+      "consultant",
+      "analyst",
+      "solution consultant"
+    ]
+  }
+}

vocab.py

@@ -0,0 +1,174 @@
+import json
+import re
+from collections import Counter
+
+# ── Raw resume text ───────────────────────────────────────────────────────────
+RESUME_TEXT = """
+NILESH HANOTIA
+AI Implementation Lead | POC-to-Production Specialist | Enterprise AI Deployment
+Ahmedabad, India | +91-9925537229 | nilesh.hanotia@outlook.com
+
+CERTIFICATIONS
+AWS Certified AI Practitioner | Amazon Web Services
+
+PROFESSIONAL SUMMARY
+AI implementation leader with 7+ years driving enterprise AI deployments from first discovery call through
+production go-live. Specialise in POC design and execution, stakeholder alignment, and translating complex
+LLM/AWS architectures into measurable business outcomes. At Armakuni, serve as the bridge between technical
+delivery teams and enterprise clients — owning the full 11-stage POC lifecycle: project allocation, internal/external
+kick-offs, weekly governance, execution, testing, delivery, and path-to-production planning. Independently
+delivered 6+ AI products generating $5M+ combined revenue, with proven impact in healthcare, legal, analytics,
+and automation domains.
+
+CORE COMPETENCIES
+AI Implementation & POC Delivery: End-to-end POC lifecycle ownership, POC→Production roadmapping,
+enterprise AI adoption strategy, deployment governance, MVP scoping, client validation
+Technical Fluency: LLM pipelines & AI workflows, AWS services (Lambda, Bedrock, API Gateway, DynamoDB,
+CloudWatch), serverless architecture, API integrations, solution architecture collaboration, logging & observability
+(Langfuse, Langsmith)
+Stakeholder & Delivery Leadership: Executive alignment, discovery workshops, SOW-to-delivery conversion,
+weekly PSR reporting, risk & escalation management, account expansion strategy, cross-functional team
+coordination
+
+PROFESSIONAL EXPERIENCE
+Customer Solution Consultant (CSC) — AI Implementation — Armakuni 2025 – Present
+Own end-to-end delivery of AI POCs and rapid engagements (5–8 weeks) across enterprise clients in healthcare,
+legal, and automation sectors.
+- Drive the full 11-stage POC lifecycle: project allocation, SOW review, internal/external kick-offs, planning,
+weekly governance, execution oversight, testing & client validation, delivery, and path-to-production.
+- Convert Statements of Work into executable delivery plans with milestones, sprint cadences, RACI matrices,
+and risk registers.
+- Serve as primary bridge between developers, solution architects, DevOps, and enterprise client
+stakeholders — ensuring technical decisions align with business outcomes.
+- Lead weekly executive reporting (PSR), risk management, and scope control; escalate proactively across a
+structured L1→L3 escalation matrix.
+- Develop deep working knowledge of AWS services (Lambda, Bedrock, API Gateway, CloudWatch) and LLM
+pipeline architecture to engage credibly with both technical teams and client leadership.
+- Create and maintain technical documentation — process flows, README files, test cases — to ensure
+production readiness from day one of execution.
+- Facilitate path-to-production workshops with clients, mapping POC learnings to scalable architecture,
+compliance requirements (GDPR, HIPAA), and business value expansion plans.
+- Identify account expansion, cross-sell, and upsell opportunities, contributing to long-term Armakuni account
+growth strategy.
+
+AI Product & Implementation Lead — Independent Consultant 2021 – 2025
+Delivered AI products end-to-end — from problem discovery and architecture design through deployment, user
+adoption, and ongoing iteration — serving 10,000+ users across multiple industries.
+- Designed and deployed 6+ production AI systems generating $5M+ combined revenue across healthcare,
+legal, enterprise analytics, and automation domains.
+- Led full AI product lifecycle: stakeholder discovery, requirements definition, LLM workflow design, MVP
+build, UAT, and phased production rollout.
+- Reduced manual client workflows by 80-90% through targeted AI automation, directly measurable in client
+operations.
+- Translated complex enterprise business needs into implementable technical architectures — working hands-on
+across AWS, API integrations, and AI/LLM pipelines.
+- Built and validated AI products with real users, iterating rapidly based on adoption data and feedback to
+drive retention and expansion.
+- Simultaneously built independent projects including real-time trading systems on AWS (Lambda,
+DynamoDB, API Gateway, Bedrock, CloudWatch) — deepening hands-on serverless and AI infrastructure expertise.
+
+EARLIER CAREER
+Product Analyst — Cignex Datamatics 2020 – 2021
+Business Product Analyst — Cygnet Infotech 2019 – 2020
+Associate Product Manager — Aimdek Technologies 2017 – 2019
+
+TECHNICAL TOOLING
+Cloud & AI: AWS (Lambda, Bedrock, API Gateway, DynamoDB, CloudWatch, CloudFront, CDK) | LLM Pipelines | Langfuse | Langsmith
+Dev & Data: Python | SQL | APIs | Docker | Tableau | Mixpanel
+Delivery & Design: Jira | Zoho Projects | Figma | Panda.doc | Agile/Scrum
+
+EDUCATION
+Post Graduate Diploma in Business Administration — St. Kabir Institute
+Bachelor of Commerce — IGNOU
+"""
+
+# ── Step 1: Build character-level vocabulary ──────────────────────────────────
+def build_vocab(text):
+    # Count frequency of every character
+    char_counts = Counter(text)
+
+    # Sort by frequency (most common first)
+    sorted_chars = sorted(char_counts.items(), key=lambda x: -x[1])
+
+    # Assign ID to each unique character
+    stoi = {ch: idx for idx, (ch, _) in enumerate(sorted_chars)}
+    itos = {idx: ch for ch, idx in stoi.items()}
+
+    return stoi, itos, char_counts, sorted_chars
+
+# ── Step 2: Encode full text ───────────────────────────────────────────────────
+def encode(text, stoi):
+    return [stoi[ch] for ch in text if ch in stoi]
+
+# ── Step 3: Extract key terms from resume ─────────────────────────────────────
+def extract_keywords(text):
+    text_lower = text.lower()
+
+    skills      = ["python", "aws", "sql", "docker", "llm", "bedrock", "lambda",
+                   "api", "langfuse", "langsmith", "tableau", "figma", "jira", "cdk"]
+    education   = ["bachelor", "post graduate", "diploma", "commerce", "business administration"]
+    experience  = re.findall(r'(\d+)\+?\s*years?', text_lower)
+    locations   = ["ahmedabad", "india"]
+    roles       = ["ai implementation", "product manager", "consultant", "analyst",
+                   "product lead", "solution consultant"]
+
+    found_skills    = [s for s in skills    if s in text_lower]
+    found_education = [e for e in education if e in text_lower]
+    found_roles     = [r for r in roles     if r in text_lower]
+
+    return {
+        "skills"    : found_skills,
+        "education" : found_education,
+        "experience": experience,
+        "location"  : locations,
+        "roles"     : found_roles
+    }
+
+# ── Main ───────────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    print("=" * 55)
+    print("       VOCABULARY BUILDER — NILESH HANOTIA RESUME")
+    print("=" * 55)
+
+    stoi, itos, char_counts, sorted_chars = build_vocab(RESUME_TEXT)
+
+    print(f"\nTotal characters (with repeats) : {len(RESUME_TEXT)}")
+    print(f"Unique characters               : {len(stoi)}")
+    print(f"Vocab size                      : {len(stoi)}")
+
+    print("\n── Top 15 most frequent characters ──")
+    for ch, count in sorted_chars[:15]:
+        display = repr(ch)
+        print(f"  {display:6s} → ID {stoi[ch]:3d}  |  appears {count:4d} times")
+
+    print("\n── Full Character → ID mapping ──")
+    for ch, idx in stoi.items():
+        display = repr(ch)
+        print(f"  {display:6s} → {idx}")
+
+    # Encode a sample
+    sample = "AI Implementation Lead with AWS and Python skills"
+    encoded = encode(sample, stoi)
+    print(f"\n── Sample Encoding ──")
+    print(f"  Text    : {sample}")
+    print(f"  Encoded : {encoded}")
+
+    # Extract keywords
+    print(f"\n── Extracted Keywords from Resume ──")
+    keywords = extract_keywords(RESUME_TEXT)
+    for key, values in keywords.items():
+        print(f"  {key:12s}: {values}")
+
+    # Save vocab to JSON
+    vocab_data = {
+        "stoi"      : stoi,
+        "itos"      : {str(k): v for k, v in itos.items()},
+        "vocab_size": len(stoi),
+        "keywords"  : extract_keywords(RESUME_TEXT)
+    }
+
+    with open("vocab.json", "w") as f:
+        json.dump(vocab_data, f, indent=2)
+
+    print(f"\n✅ vocab.json saved — {len(stoi)} characters mapped")
+    print("✅ Ready for Step 2: Tokenizer")