The Missing Piece

We have a model (Part 1) and tools (Part 2). But right now, using them requires manual orchestration — call the model, check if it wants tools, execute them, feed results back, call the model again, check again… This is tedious and error-prone. What if the model needs 15 tool calls to scaffold an entire React app?

We need an agentic loop: an automated cycle that handles the entire call-tools-respond flow. This is the core of every AI coding agent — Cursor, Claude Code, and Copilot all have one. Here’s what ours looks like:

User message
    │
    ▼
┌──────────────────────────────────┐
│          AGENTIC LOOP            │
│                                  │
│  Call model with history + tools │
│           │                      │
│           ▼                      │
│    ┌─ Tool calls? ──┐           │
│    │ Yes             │ No        │
│    ▼                 ▼           │
│  Execute tools   Return text    │
│  Feed results    ───► EXIT      │
│  back to model                  │
│    │                             │
│    └──── loop ◄─────┘           │
└──────────────────────────────────┘

Let’s build it.

Typed Events — What the Loop Emits

Our agent loop is a producer: it yields events as things happen. The consumer (your CLI or UI) decides how to display them. Using C# IAsyncEnumerable and a typed event hierarchy makes this clean.

namespace AiSdk.Agent;
public abstract record AgentEvent;
public record ToolCallEvent(ToolCall ToolCall) : AgentEvent;
public record ToolResultEvent(string ToolName, string ToolCallId, string Result) : AgentEvent;
public record TextResponseEvent(string Text) : AgentEvent;
public record StatusEvent(string Message) : AgentEvent;
public record UsageEvent(Usage Usage, int CumulativeTokens) : AgentEvent;

Why typed events instead of IAsyncEnumerable<object>?

• Pattern matching — switch (ev) { case ToolCallEvent e: ... } is clean and type-safe
• Exhaustiveness — the compiler warns if you miss a case
• Discoverability — IntelliSense shows you exactly what events exist
• No casting — each event type carries its specific data

Agent Options — Configuration

The agent needs some knobs:

public record AgentOptions
{
    /// The system prompt that defines the agent's behavior.
    public required string SystemPrompt { get; init; }
    /// Max model calls per user message. Prevents runaway loops. Default: 50.
    public int MaxIterations { get; init; } = 50;
    /// Summarize conversation when cumulative tokens exceed this. Default: 128K.
    public int? TokenSummarizationThreshold { get; init; } = 128_000;
    /// Messages to keep when summarizing. Default: 6.
    public int MessagesToKeepOnSummarize { get; init; } = 6;
    /// Custom summarization prompt (or null for built-in default).
    public string? SummarizationSystemPrompt { get; init; }
    /// Default model parameters (Temperature, MaxTokens, etc.).
    public AgentModelCallDefaults? ModelCallDefaults { get; init; }
}

The system prompt is required because it defines the agent's entire personality and capabilities. Everything else has sensible defaults.

The Agent Class

Here’s the full implementation. It’s ~160 lines — let’s walk through it section by section.

Constructor

using AiSdk.Abstractions;
using AiSdk.Tools;
namespace AiSdk.Agent;
public class Agent
{
    private readonly ILanguageModel _model;
    private readonly ToolRegistry _tools;
    private readonly AgentOptions _options;
    private readonly List<Message> _conversationHistory = new();
    public Agent(ILanguageModel model, ToolRegistry tools, AgentOptions options)
    {
        _model = model;
        _tools = tools;
        _options = options;
        // Seed the conversation with the system prompt
        _conversationHistory.Add(new Message(MessageRole.System, options.SystemPrompt));
    }
    public IReadOnlyList<Message> ConversationHistory => _conversationHistory.AsReadOnly();
}

Three dependencies, all injected:

• ILanguageModel — any provider (OpenAI, Anthropic, Azure, etc.)
• ToolRegistry — any set of tools
• AgentOptions — configuration including the system prompt

The conversation history is seeded with the system prompt and persists across SendMessageAsync calls, giving the model memory of the entire session.

The Agentic Loop

This is the core method:

public async IAsyncEnumerable<AgentEvent> SendMessageAsync(
    string input,
    [EnumeratorCancellation] CancellationToken ct = default)
{
    _conversationHistory.Add(new Message(MessageRole.User, input));
    int cumulativeTokens = 0;
    for (int iteration = 0; iteration < _options.MaxIterations; iteration++)
    {
        // 1. Check if we need to summarize (approaching context limits)
        if (_options.TokenSummarizationThreshold is int threshold
            && cumulativeTokens > threshold)
        {
            yield return new StatusEvent("Summarizing conversation to free up context...");
            await SummarizeConversationAsync(ct);
            cumulativeTokens = 0;
            yield return new StatusEvent("Context compressed - continuing");
        }
        // 2. Call the model
        var callOptions = BuildCallOptions();
        var result = await _model.GenerateAsync(callOptions, ct);
        // 3. Track token usage
        cumulativeTokens += result.Usage?.TotalTokens ?? 0;
        if (result.Usage is not null)
            yield return new UsageEvent(result.Usage, cumulativeTokens);
        // 4. Handle the response
        if (result.FinishReason == FinishReason.ToolCalls && result.ToolCalls?.Count > 0)
        {
            // Model wants to call tools - execute them and continue the loop
            foreach (var toolCall in result.ToolCalls)
                yield return new ToolCallEvent(toolCall);
            var toolResultsSb = new StringBuilder();
            foreach (var toolCall in result.ToolCalls)
            {
                var toolResult = await _tools.ExecuteAsync(
                    toolCall.ToolName, toolCall.Arguments, ct);
                toolResultsSb.AppendLine(
                    $"<tool_result name=\"{toolCall.ToolName}\" " +
                    $"id=\"{toolCall.ToolCallId}\">");
                toolResultsSb.AppendLine(toolResult);
                toolResultsSb.AppendLine("</tool_result>");
                yield return new ToolResultEvent(
                    toolCall.ToolName, toolCall.ToolCallId, toolResult);
            }
            // Add to conversation history and loop
            if (!string.IsNullOrEmpty(result.Text))
                _conversationHistory.Add(new Message(MessageRole.Assistant, result.Text));
            _conversationHistory.Add(new Message(MessageRole.User, toolResultsSb.ToString()));
        }
        else
        {
            // Final text response - we're done
            var text = result.Text ?? "";
            _conversationHistory.Add(new Message(MessageRole.Assistant, text));
            yield return new TextResponseEvent(text);
            yield break;
        }
    }
    yield return new StatusEvent($"Reached maximum iterations ({_options.MaxIterations})");
}

Let’s break down the key decisions:

Why IAsyncEnumerable? Because the agent produces events over time — it might make 10 tool calls before producing a final response. IAsyncEnumerable<AgentEvent> lets the consumer process events as they happen (show tool progress in real time) instead of waiting for everything to finish.

Why feed tool results as User messages? Most LLM APIs expect the conversation to alternate between user/assistant roles. Tool results are information the model needs to continue, so they go in as user messages wrapped in <tool_result> XML tags. The model reads these and decides what to do next.

Why MaxIterations? Without a limit, a confused model could loop forever — calling tools that fail, retrying, failing again. 50 iterations is generous enough for complex tasks but prevents infinite loops.

Why track cumulative tokens? The conversation grows with every tool call and result. A single “build me a React app” prompt might generate 100K+ tokens of tool calls and results. When we approach the model’s context limit, we summarize to avoid errors.

Conversation Summarization

When the conversation gets too long, the agent compresses it:

private async Task SummarizeConversationAsync(CancellationToken ct)
{
    int recentToKeep = _options.MessagesToKeepOnSummarize;
    if (_conversationHistory.Count <= recentToKeep + 2)
        return;
    // Split: [system prompt] [old messages to summarize] [recent messages to keep]
    int summarizeEnd = _conversationHistory.Count - recentToKeep;
    var toSummarize = _conversationHistory.GetRange(1, summarizeEnd - 1);
    // Build text representation of messages to summarize
    var historyText = new StringBuilder();
    foreach (var msg in toSummarize)
    {
        var content = msg.Content;
        if (content.Length > 2000)
            content = content[..2000] + "...[truncated]";
        historyText.AppendLine($"[{msg.Role}]: {content}");
    }
    // Ask the model to summarize
    var summarizeMessages = new List<Message>
    {
        new(MessageRole.System, SummarizationPrompt),
        new(MessageRole.User, $"Summarize this conversation:\n\n{historyText}")
    };
    var result = await _model.GenerateAsync(new LanguageModelCallOptions
    {
        Messages = summarizeMessages
    }, ct);
    // Rebuild: [system prompt] [summary] [recent messages]
    var recentMessages = _conversationHistory
        .GetRange(summarizeEnd, _conversationHistory.Count - summarizeEnd);
    _conversationHistory.Clear();
    _conversationHistory.Add(new Message(MessageRole.System, _options.SystemPrompt));
    _conversationHistory.Add(new Message(MessageRole.Assistant,
        $"[Conversation Summary]\n{result.Text}"));
    _conversationHistory.AddRange(recentMessages);
}

The strategy: keep the system prompt, keep the last N messages (for immediate context), and replace everything in between with a summary. The model gets enough context to continue working without re-reading files.

Putting It All Together — The Vibe Coder

Now we wire everything up. The application-specific code is tiny — just credentials, system prompt, and a UI loop.

The Wrapper (BlzAgent.cs)

using AiSdk.Agent;
using AiSdk.Providers.Azure;
using AiSdk.Tools;

public class BlzAgent
{
    private readonly Agent _agent;
    public BlzAgent(string? workingDirectory = null)
    {
        var workDir = workingDirectory ?? Directory.GetCurrentDirectory();
        var model = AzureOpenAIProvider.CreateChatModel(
            deploymentName: "gpt-4o",
            endpoint: "https://my-resource.openai.azure.com",
            apiKey: "your-key"
        );
        var tools = VibeCodingTools.CreateRegistry(workDir);
        _agent = new Agent(model, tools, new AgentOptions
        {
            SystemPrompt = $"""
                You are an expert software engineer.
                Your working directory is: {workDir}
                CRITICAL RULES:
                - ALWAYS use tools to create and modify files. Never just output code as text.
                - Use read_file before edit_file so you know the exact content to replace.
                - Use bash to run builds, tests, and other commands.
                - Use absolute paths based on the working directory.
                """
        });
    }
    public IAsyncEnumerable<AgentEvent> SendMessage(string input)
        => _agent.SendMessageAsync(input);
    public void ResetConversation()
        => _agent.ResetConversation();
}

That’s it. ~30 lines. The generic Agent class handles the entire agentic loop. BlzAgent is just configuration: which provider, which tools, what system prompt.

The CLI (Program.cs)

using AiSdk.Agent;
var agent = new BlzAgent(args.Length > 0 ? args[0] : Directory.GetCurrentDirectory());
Console.WriteLine("Type your request. /reset to clear, /quit to exit.\n");
while (true)
{
    Console.ForegroundColor = ConsoleColor.Green;
    Console.Write("You > ");
    Console.ResetColor();
    var input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input)) continue;
    if (input.Trim().Equals("/quit", StringComparison.OrdinalIgnoreCase)) break;
    if (input.Trim().Equals("/reset", StringComparison.OrdinalIgnoreCase))
    {
        agent.ResetConversation();
        Console.WriteLine("  [Conversation reset]\n");
        continue;
    }
    Console.WriteLine();
    try
    {
        await foreach (var ev in agent.SendMessage(input))
        {
            switch (ev)
            {
                case ToolCallEvent { ToolCall: var tc }:
                    Console.ForegroundColor = ConsoleColor.DarkCyan;
                    Console.Write($"  > {tc.ToolName}");
                    Console.ResetColor();
                    var args = tc.Arguments.RootElement.GetRawText();
                    if (args.Length > 120) args = args[..120] + "...";
                    Console.WriteLine($"  {args}");
                    break;
                case ToolResultEvent { Result: var result }:
                    Console.ForegroundColor = ConsoleColor.DarkGray;
                    var preview = result.ReplaceLineEndings(" ");
                    if (preview.Length > 150) preview = preview[..150] + "...";
                    Console.WriteLine($"    OK {preview}");
                    Console.ResetColor();
                    break;
                case TextResponseEvent { Text: var text }:
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write(text);
                    Console.ResetColor();
                    break;
                case StatusEvent { Message: var msg }:
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine($"  [{msg}]");
                    Console.ResetColor();
                    break;
                case UsageEvent:
                    break; // Silently ignore
            }
        }
    }
    catch (Exception ex)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"\n  [Error] {ex.Message}");
        Console.ResetColor();
    }
    Console.WriteLine("\n" + new string('-', 60) + "\n");
}

The pattern matching on AgentEvent subtypes makes the display logic clean and extensible. Want to add a token counter? Handle UsageEvent. Want to log tool calls? Handle ToolCallEvent. The agent doesn't care what you do with the events.

Swapping Providers — The Payoff

Because Agent takes ILanguageModel, switching providers is a one-line change:

// Azure OpenAI
var model = AzureOpenAIProvider.CreateChatModel("gpt-4o", endpoint, apiKey);
// OpenAI directly
var model = OpenAIProvider.CreateChatModel("gpt-4o", apiKey: "sk-...");
// Anthropic Claude
var model = AnthropicProvider.CreateChatModel("claude-3-5-sonnet-20241022", apiKey: "sk-ant-...");\
// Google Gemini
var model = GoogleProvider.CreateChatModel("gemini-pro", apiKey: "...");
// Groq (fast inference)
var model = GroqProvider.CreateChatModel("llama-3.1-70b-versatile", apiKey: "...");

Same tools. Same agent. Same CLI. Different brain.

Architecture Summary

Here’s the final architecture, showing how everything connects:

┌─────────────────────────────────────────────────┐
│ Program.cs (CLI)                                │
│   Handles user I/O, displays AgentEvents        │
└────────────────────┬────────────────────────────┘
                     │ IAsyncEnumerable<AgentEvent>
                     │
┌────────────────────▼────────────────────────────┐
│ BlzAgent (thin wrapper)                         │
│   Azure credentials + system prompt             │
│   Creates: model, tools, Agent                  │
└────────────────────┬────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────┐
│ Agent (AiSdk.Agent)               GENERIC       │
│   Agentic loop: model → tools → loop            │
│   Conversation history + summarization          │
│   Emits: ToolCallEvent, ToolResultEvent,        │
│          TextResponseEvent, StatusEvent,         │
│          UsageEvent                              │
├─────────────────┬───────────────────────────────┤
│ ILanguageModel  │  ToolRegistry                 │
│ (any provider)  │  (any tools)                  │
└─────────────────┴───────────────────────────────┘

The generic layer (Agent, AgentEvent, AgentOptions, ToolRegistry) lives in the AI SDK NuGet package. Your application only provides:

1. A provider — which LLM to use
2. Tools — what the agent can do
3. A system prompt — how the agent should behave
4. A UI — how to display events

What You Could Build Next

This foundation opens up a lot of possibilities:

• Streaming responses — Use model.StreamAsync() in the agent loop for real-time token-by-token text output
• Tool confirmation — Emit a ToolConfirmationEvent before executing destructive tools (rm, drop table), let the user approve/reject
• Multi-model routing — Use a fast/cheap model for simple tool calls, a powerful model for complex reasoning
• Web UI — The IAsyncEnumerable<AgentEvent> stream maps naturally to Server-Sent Events or SignalR
• MCP integration — Load tools dynamically from Model Context Protocol servers instead of hardcoding them
• Parallel tool execution — When the model requests multiple independent tool calls, execute them concurrently

The agentic loop pattern is the same regardless. The model calls tools, you execute them, feed results back, repeat. Everything else is details.

Wrapping Up

Across these three articles, we’ve built a complete vibe coding tool:

1. Part 1 — Connected to an LLM through the AI SDK’s unified ILanguageModel interface
2. Part 2 — Built tools that let the model read files, write files, edit code, search codebases, and run shell commands
3. Part 3 — Wrapped it all in an agentic loop that autonomously orchestrates tool calls until the task is complete

The total application-specific code is about 50 lines (BlzAgent.cs). Everything else is reusable: the Agent, the event system, and the ToolRegistry work with any provider and any tool set.

That’s the power of building on a good abstraction layer. The AI SDK gives you the model interface. The Agent gives you the loop. You just bring the tools and the prompt.

Happy vibe coding.

Build Your Own Vibe Coding Tool with AI SDK for .NET — Part 3: Building the Agent was originally published in Predict on Medium, where people are continuing the conversation by highlighting and responding to this story.

From Chatbot to Agent

In Part 1, we built a chat loop. The model can answer questions, but it can’t do anything — it can’t read your files, create projects, or run builds. To make a vibe coding tool, the model needs to interact with the filesystem and shell.

This is what tool calling (also known as function calling) solves. You tell the model what tools are available, and it decides when and how to call them. The model doesn’t execute the tools itself — it returns structured “please call this tool with these arguments” messages, and your code runs them.

The flow looks like this:

You: "Create a hello.txt file"
        │
        ▼
   ┌─────────┐
   │  Model   │ ──► ToolCall: write_file({ path: "hello.txt", content: "Hello!" })
   └─────────┘
        │
        ▼
   Your code executes write_file, gets result: "OK, wrote 6 chars"
        │
        ▼
   Feed result back to model
        │
        ▼
   ┌─────────┐
   │  Model   │ ──► "Done! I created hello.txt with a greeting."
   └─────────┘

The AI SDK makes this easy with three building blocks: Tool definitions, ToolWithExecution, and ToolRegistry.

How Tool Calling Works Under the Hood

When you pass tools to the model, the SDK sends a JSON Schema describing each tool’s name, description, and parameters. The model can then respond with a special ToolCalls finish reason, indicating it wants to invoke one or more tools.

Here’s what the model sees (conceptually):

{
  "tools": [
    {
      "name": "write_file",
      "description": "Create or overwrite a file with the provided content.",
      "parameters": {
        "type": "object",
        "properties": {
          "filePath": { "type": "string", "description": "Absolute path to the file." },
          "content": { "type": "string", "description": "The content to write." }
        },
        "required": ["filePath", "content"]
      }
    }
  ]
}

And here’s what comes back when the model decides to use the tool:

result.FinishReason == FinishReason.ToolCalls
result.ToolCalls[0].ToolName == "write_file"
result.ToolCalls[0].Arguments == { "filePath": "hello.txt", "content": "Hello!" }
result.ToolCalls[0].ToolCallId == "call_abc123"

Your job: execute the tool call, and send the result back to the model as a new message.

Building Your First Tool

Step 1: Define the Input Type

Every tool needs a strongly-typed input. Use [JsonPropertyName] for the property names the model will use, and [Description] to tell the model what each parameter does:

using System.ComponentModel;
using System.Text.Json.Serialization;
public class WriteFileInput
{
    [JsonPropertyName("filePath")]
    [Description("Absolute path to the file to create or overwrite.")]
    public string FilePath { get; set; } = "";
    [JsonPropertyName("content")]
    [Description("The full content to write to the file.")]
    public string Content { get; set; } = "";
}

Why [JsonPropertyName] matters: The SDK's schema generator sends camelCase names to the model (so the model sees filePath), but C#'s JsonSerializer.Deserialize defaults to PascalCase matching. Without [JsonPropertyName], the model's arguments won't deserialize correctly — all properties will be empty/default.

Why [Description] matters: These descriptions are included in the JSON Schema sent to the model. They're the model's documentation for how to use the tool. Good descriptions lead to fewer mistakes.

Step 2: Create the Tool

Use Tool.Create<TInput, TOutput>() to pair the definition with an execution function:

using AiSdk.Tools;
var writeFileTool = Tool.Create<WriteFileInput, string>(
    "write_file",
    "Create a new file or overwrite an existing file with the provided content.",
    (input, ct) =>
    {
        var dir = Path.GetDirectoryName(input.FilePath);
        if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
            Directory.CreateDirectory(dir);
        File.WriteAllText(input.FilePath, input.Content);
        var lineCount = input.Content.Split('\n').Length;
        return Task.FromResult(
            $"Successfully wrote {input.Content.Length} chars ({lineCount} lines) to {input.FilePath}");
    });

Here’s what happens behind the scenes:

1. Schema generation: Tool.Create calls JsonSchemaGenerator.GenerateSchema<WriteFileInput>(), which uses reflection to inspect the type — its properties, their types, [JsonPropertyName] attributes, [Description] attributes, and nullability. It produces a JSON Schema that describes the tool's parameters.
2. Definition creation: A ToolDefinition record is created with the name, description, and generated schema.
3. Execution pairing: The execution function is stored alongside the definition in a ToolWithExecution<TInput, TOutput> object.

The result is a single object that knows both how to describe itself to the model and how to execute when called.

How the Schema Generator Works

The schema generator handles C# types recursively:

| `string` | `{ "type": "string" }` |
| `int`, `long` | `{ "type": "integer" }` |
| `double`, `float` | `{ "type": "number" }` |
| `bool` | `{ "type": "boolean" }` |
| `enum` | `{ "type": "string", "enum": ["Value1", "Value2"] }` |
| `List<T>`, `T[]` | `{ "type": "array", "items": { ... } }` |
| class/record | `{ "type": "object", "properties": { ... }, "required": [...] }` |

Non-nullable properties are added to the required array. Nullable properties (string?, int?) are optional.

For example, this input type:

public class GrepInput
{
    [JsonPropertyName("pattern")]
    [Description("Text or regex pattern to search for.")]
    public string Pattern { get; set; } = "";
    [JsonPropertyName("path")]
    [Description("Directory to search in. Defaults to working directory.")]
    public string? Path { get; set; }
    [JsonPropertyName("include")]
    [Description("File filter (e.g. '*.cs'). Defaults to all files.")]
    public string? Include { get; set; }
}

Generates this schema (sent to the model):

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "description": "Text or regex pattern to search for."
    },
    "path": {
      "type": "string",
      "description": "Directory to search in. Defaults to working directory."
    },
    "include": {
      "type": "string",
      "description": "File filter (e.g. '*.cs'). Defaults to all files."
    }
  },
  "required": ["pattern"]
}

Notice: pattern is required (non-nullable string), while path and include are optional (nullable string?).

Step 3: Register Tools in a ToolRegistry

When you have multiple tools, you need a registry to hold them all and dispatch execution by name:

using AiSdk.Tools;

var registry = new ToolRegistry();
registry.Register(writeFileTool);
registry.Register(readFileTool);
registry.Register(bashTool);
// ... register more tools

The registry provides two things:

Definitions — the list of ToolDefinition objects to pass to the model:

var options = new LanguageModelCallOptions 
    {     
        Messages = history,     
        Tools = registry.Definitions  // ← All tool schemas for the model 
    };

ExecuteAsync — type-erased execution by tool name:

string result = await registry.ExecuteAsync(
    toolCall.ToolName,      // e.g. "write_file"
    toolCall.Arguments      // JsonDocument with the arguments
);

The registry handles deserialization (JSON → your input type), execution, and error catching internally. If a tool throws, the registry catches the exception and returns an error string — this is important because you want the model to see the error and try to recover, not crash your application.

Building a Real Tool Set

For a vibe coding tool, you need tools that cover file operations, code search, and shell execution. Here’s how to build the essential ones.

read_file — Read with Line Numbers

public class ReadFileInput
{
    [JsonPropertyName("filePath")]
    [Description("Absolute path to the file to read.")]
    public string FilePath { get; set; } = "";
    [JsonPropertyName("offset")]
    [Description("Line offset to start from (0-based). Omit to read from the beginning.")]
    public int? Offset { get; set; }
    [JsonPropertyName("limit")]
    [Description("Max lines to read. Omit to read the entire file.")]
    public int? Limit { get; set; }
}

var readFileTool = Tool.Create<ReadFileInput, string>(
    "read_file",
    "Read file contents with line numbers. Supports offset and limit for large files.",
    (input, ct) =>
    {
        if (!File.Exists(input.FilePath))
            return Task.FromResult($"Error: File not found: {input.FilePath}");
        var lines = File.ReadAllLines(input.FilePath);
        int offset = Math.Max(0, input.Offset ?? 0);
        int limit = input.Limit ?? lines.Length;
        var sb = new StringBuilder();
        var selected = lines.Skip(offset).Take(limit).ToArray();
        for (int i = 0; i < selected.Length; i++)
            sb.AppendLine($"{offset + i + 1,5}| {selected[i]}");
        return Task.FromResult(sb.ToString());
    });

Design note: Line numbers matter. When the model uses edit_file later, it needs to identify exact locations. The offset/limit parameters let it read portions of large files without blowing up the context.

edit_file — Surgical Find-and-Replace

public class EditFileInput
{
    [JsonPropertyName("filePath")]
    [Description("Absolute path to the file to edit.")]
    public string FilePath { get; set; } = "";

    [JsonPropertyName("oldString")]
    [Description("The exact string to find. Must match exactly including whitespace.")]
    public string OldString { get; set; } = "";
    [JsonPropertyName("newString")]
    [Description("The replacement string.")]
    public string NewString { get; set; } = "";
}

var editFileTool = Tool.Create<EditFileInput, string>(
"edit_file",
"Edit a file by finding and replacing an exact string. The old_string must appear exactly once.",
(input, ct) =>
{
    if (!File.Exists(input.FilePath))
        return Task.FromResult($"Error: File not found: {input.FilePath}");
    var content = File.ReadAllText(input.FilePath);
    if (!content.Contains(input.OldString))
        return Task.FromResult($"Error: old_string not found in {input.FilePath}");
    // Ensure uniqueness - ambiguous edits are dangerous
    var count = CountOccurrences(content, input.OldString);
    if (count > 1)
        return Task.FromResult(
            $"Error: old_string found {count} times. Provide more context to make it unique.");
    var newContent = content.Replace(input.OldString, input.NewString);
    File.WriteAllText(input.FilePath, newContent);
    return Task.FromResult($"Successfully edited {input.FilePath}");
});

Design note: Requiring the oldString to be unique is critical. Without this, a naive replace could modify the wrong occurrence and silently corrupt the file. If the model gets an error, it can retry with more surrounding context to make the match unique.

bash — Shell Execution

This is the most powerful tool — and the trickiest to get right:

public class BashInput
{
    [JsonPropertyName("command")]
    [Description("The shell command to execute.")]
    public string Command { get; set; } = "";
[JsonPropertyName("workingDirectory")]
    [Description("Working directory. Defaults to project root.")]
    public string? WorkingDirectory { get; set; }
    [JsonPropertyName("timeout")]
    [Description("Timeout in seconds. Default is 60.")]
    public int Timeout { get; set; } = 60;
}

var bashTool = Tool.Create<BashInput, string>(
    "bash",
    "Execute a shell command. Returns stdout, stderr, and exit code.",
    async (input, ct) =>
    {
        var psi = new ProcessStartInfo
        {
            FileName = "cmd.exe",
            Arguments = $"/c {input.Command}",
            WorkingDirectory = input.WorkingDirectory ?? workingDir,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            RedirectStandardInput = true,
            UseShellExecute = false,
            CreateNoWindow = true
        };
        // Skip interactive prompts in CI-style tools
        psi.Environment["CI"] = "true";
        psi.Environment["npm_config_yes"] = "true";
        var process = Process.Start(psi)!;
        process.StandardInput.Close(); // EOF prevents hanging on prompts
        // ... read output, handle timeouts, return result
    });

Two critical gotchas for bash tools:

1. Confirmation prompts: Commands like npm create vite@latest ask "Ok to proceed? (y)" and block forever. Fix: set CI=true and npm_config_yes=true environment variables, redirect stdin and close it immediately.
2. Long-running processes: npm run dev starts a dev server that never exits. If you use ReadToEndAsync + WaitForExitAsync, you block forever. Fix: read output incrementally and use an idle timeout — if the process stops producing output for 5 seconds (e.g., after printing "ready in 500ms"), return what you have and let the process continue in the background.

Organizing Tools in a Factory

Group all tool creation in a static factory class:

public static class VibeCodingTools
{
    public static ToolRegistry CreateRegistry(string workingDirectory)
    {
        var registry = new ToolRegistry();
        registry.Register(CreateReadFileTool());
        registry.Register(CreateWriteFileTool());
        registry.Register(CreateEditFileTool());
        registry.Register(CreateGlobTool(workingDirectory));
        registry.Register(CreateGrepTool(workingDirectory));
        registry.Register(CreateBashTool(workingDirectory));
        registry.Register(CreateMkdirTool());
        // ... more tools
        return registry;
    }
    private static ToolWithExecution<ReadFileInput, string> CreateReadFileTool() =>
        Tool.Create<ReadFileInput, string>("read_file", "...", (input, ct) => { ... });
    // ... other Create methods
}

This keeps tool definitions clean and testable. The workingDirectory parameter is threaded through to tools that need a default base path (glob, grep, bash).

Tool Calling in Action

Here’s the manual version of what the agent loop does (we’ll automate this in Part 3):

var registry = VibeCodingTools.CreateRegistry(@"C:\projects");
var history = new List<Message>
{
    new(MessageRole.System, "You are a coding assistant. Use your tools."),
    new(MessageRole.User, "Create a file called hello.txt with 'Hello, World!'")
};
// 1. Call the model with tools available
var result = await model.GenerateAsync(new LanguageModelCallOptions
{
    Messages = history,
    Tools = registry.Definitions
});
// 2. Check if the model wants to call tools
if (result.FinishReason == FinishReason.ToolCalls)
{
    foreach (var toolCall in result.ToolCalls!)
    {
        Console.WriteLine($"Tool: {toolCall.ToolName}");
        // 3. Execute the tool
        var toolResult = await registry.ExecuteAsync(
            toolCall.ToolName, toolCall.Arguments);
        Console.WriteLine($"Result: {toolResult}");
        // 4. Feed the result back to the model
        history.Add(new Message(MessageRole.User,
            $"<tool_result name=\"{toolCall.ToolName}\">{toolResult}</tool_result>"));
    }
    // 5. Call the model again so it can respond or call more tools
    result = await model.GenerateAsync(new LanguageModelCallOptions
    {
        Messages = history,
        Tools = registry.Definitions
    });
    Console.WriteLine(result.Text);
}

The model might call one tool, or five tools, or call tools in a chain where later calls depend on earlier results. That’s why we need a loop — which is exactly what Part 3 covers.

The Tool Design Checklist

When building tools for an AI agent, keep these principles in mind:

1. Return errors, don’t throw. The model should see “Error: File not found” and try something else, not crash your application. The ToolRegistry wraps execution in try-catch, but returning clean error strings gives the model better information.
2. Descriptions are documentation. The model reads your tool descriptions and parameter descriptions to decide when and how to use each tool. Be specific. “Execute a shell command” is better than “Run stuff.”
3. Validate inputs defensively. The model might send malformed paths or missing arguments. Check for nulls, verify paths exist, validate ranges.
4. Truncate large outputs. Tool results go back into the conversation history and consume tokens. If grep finds 10,000 matches, truncate to 100 with a note. If a file is 50KB, show the first portion.
5. Make tools composable. The model should be able to read_file → edit_file → bash (run tests) in sequence. Each tool should work independently.

What’s Next

We now have a model and a set of tools. But the manual “call model → check for tools → execute → feed back → repeat” loop is tedious and limited. What if the model needs to call tools 10 times in a row?

In Part 3, we’ll build the Agent — a generic agentic loop that:

• Calls the model with conversation history and tools
• Automatically executes any tool calls
• Feeds results back and loops until the model produces a final text response
• Handles conversation summarization when context gets too long
• Emits typed events so your UI can display progress in real time

This is where everything comes together into a real vibe coding tool.

Build Your Own Vibe Coding Tool with AI SDK for .NET — Part 2: Building Tools was originally published in Predict on Medium, where people are continuing the conversation by highlighting and responding to this story.

• Part 1 (this article): The AI SDK — providers, models, messages, and generating text
• Part 2: Building Tools — teaching the model to interact with the real world
• Part 3: Building the Agent — the agentic loop that ties everything together

What We’re Building

“Vibe coding” is a term coined by Andrej Karpathy — the idea that you describe what you want in natural language and an AI builds it. Tools like Cursor, Windsurf, and Claude Code do this inside editors. We’re going to build one from scratch as a standalone CLI, using the AI SDK for .NET NuGet package.

Here’s what the finished product looks like:

You > Create a React todo app with add, complete, and delete features

  > mkdir  C:\projects\todo-react
  > bash   npm create vite@latest todo-react -- --template react
    OK [exit code: 0]
  > write_file  C:\projects\todo-react\src\App.jsx
    OK wrote 1371 chars
  > bash   cd C:\projects\todo-react && npm install && npm run build
    OK [exit code: 0]
.........

Done! I created a React todo app at C:\projects\todo-react with...

The model decides what tools to call, in what order, and handles errors autonomously. Our job is to give it the right tools and a loop to run in.

Let’s start with the foundation: the AI SDK itself.

Getting Started

Create a new console app and add the AI SDK:

dotnet new console -n VibeCoder
cd VibeCoder
dotnet add package AiSdk

That single package gives you access to 30+ providers — OpenAI, Anthropic, Azure OpenAI, Google, Groq, Mistral, and many more — through a unified interface.

Core Concepts

The AI SDK is built around a few key abstractions. Once you understand these, everything else falls into place.

1. The Provider — Creating a Model

Every provider has a static factory class. You call it to get a model instance:

using AiSdk.Providers.Azure;
var model = AzureOpenAIProvider.CreateChatModel(
    deploymentName: "gpt-4o",
    endpoint: "https://my-resource.openai.azure.com",
    apiKey: "your-api-key"
);

Want to switch to OpenAI directly?

using AiSdk.Providers.OpenAI;
var model = OpenAIProvider.CreateChatModel(
    modelId: "gpt-4o",
    apiKey: "sk-..."
);

Or Anthropic?

using AiSdk.Providers.Anthropic;
var model = AnthropicProvider.CreateChatModel(
    modelId: "claude-3-5-sonnet-20241022",
    apiKey: "sk-ant-..."
);

The pattern is always the same: a static CreateChatModel method that returns an ILanguageModel. Some providers also have convenience methods like OpenAIProvider.GPT4(apiKey) for common models.

The key insight: every provider returns the same ILanguageModel interface. Your application code never needs to know which provider is behind it. This is what makes the SDK powerful — you can swap providers without changing your logic.

2. Messages — The Conversation

LLMs work with a conversation history — a list of messages with roles:

using AiSdk.Abstractions;
var messages = new List<Message>
{
    new(MessageRole.System, "You are a helpful coding assistant."),
    new(MessageRole.User, "What is a record in C#?")
};

The four roles:

SystemSets behavior, context, and rules

UserInput from the human (or tool results fed back)

AssistantModel's responses

ToolResults from tool/function execution

A Message is a simple record:

public record Message(
    MessageRole Role,
    string Content,
    string? Name = null,
    IReadOnlyDictionary<string, object>? Metadata = null);

3. Generating Text — Your First API Call

To call the model, create a LanguageModelCallOptions and call GenerateAsync:

var options = new LanguageModelCallOptions
{
    Messages = messages,
    MaxTokens = 500,
    Temperature = 0.7
};

var result = await model.GenerateAsync(options);
Console.WriteLine(result.Text);
Console.WriteLine($"Tokens used: {result.Usage.TotalTokens}");
Console.WriteLine($"Finish reason: {result.FinishReason}");

The result gives you:

• Text — the generated content
• FinishReason — why the model stopped (Stop, Length, ToolCalls, etc.)
• Usage — token counts (InputTokens, OutputTokens, TotalTokens)
• ToolCalls — any tool calls the model wants to make (we'll use this in Part 2)

4. The Convenience Layer — AiClient

For simple use cases, the SDK provides AiClient as a higher-level API:

using AiSdk;
// Simple text generation
var result = await AiClient.GenerateTextAsync(model, new GenerateTextOptions
{
    System = "You are a helpful assistant.",
    Prompt = "Explain dependency injection in one paragraph."
});

Console.WriteLine(result.Text);

AiClient handles building the message array from System + Prompt for you. It also supports streaming:

await foreach (var chunk in AiClient.StreamTextAsync(model, new GenerateTextOptions
{
    Prompt = "Write a haiku about C#"
}))
{
    Console.Write(chunk.Text);
}

5. Structured Output — Getting Objects Back

One of the most powerful features: you can ask the model to return typed C# objects instead of raw text.

public record MovieReview
{
    [Description("Rating from 1-10")]
    public int Rating { get; init; }
    public string Summary { get; init; } = "";
    [Description("Key themes identified")]
    public List<string> Themes { get; init; } = new();
}

var review = await AiClient.GenerateObjectAsync<MovieReview>(model, new GenerateObjectOptions
{
    Prompt = "Review the movie Inception",
    Mode = "tool"  // Uses tool calling for structured output
});

Console.WriteLine($"Rating: {review.Object.Rating}/10");
Console.WriteLine($"Summary: {review.Object.Summary}");

The SDK automatically generates a JSON Schema from your C# type (using [Description] attributes and [JsonPropertyName] for naming), sends it to the model, and deserializes the response back into your type.

Two modes are supported:

• "tool" — Creates a hidden tool definition; the model "calls" it with the structured data
• "json" — Appends the schema to the system prompt and parses the JSON response

Understanding LanguageModelCallOptions

This is the main options record you’ll work with when calling models directly:

public record LanguageModelCallOptions
{
    // Required
    public required IReadOnlyList<Message> Messages { get; init; }
   // Tools (Part 2)
    public IReadOnlyList<ToolDefinition>? Tools { get; init; }
    public string? ToolChoice { get; init; }  // "auto", "none", "required"
    // Generation parameters
    public int? MaxTokens { get; init; }
    public double? Temperature { get; init; }    // 0.0 = deterministic, 2.0 = creative
    public double? TopP { get; init; }
    public int? TopK { get; init; }
    public double? PresencePenalty { get; init; }
    public double? FrequencyPenalty { get; init; }
    public IReadOnlyList<string>? StopSequences { get; init; }
    public int? Seed { get; init; }              // For reproducible outputs
}

For our vibe coding tool, we’ll mostly care about Messages and Tools. The generation parameters can be left at defaults for most coding tasks (models tend to work well at low temperature for code).

Putting It Together — A Minimal Chat Loop

Here’s a working chat application in ~30 lines:

using AiSdk.Abstractions;
using AiSdk.Providers.OpenAI;
var model = OpenAIProvider.CreateChatModel("gpt-4o", apiKey: "sk-...");
var history = new List<Message>
{
    new(MessageRole.System, "You are a helpful coding assistant.")
};
while (true)
{
    Console.Write("You > ");
    var input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input)) continue;
    if (input == "/quit") break;
    history.Add(new Message(MessageRole.User, input));
    var result = await model.GenerateAsync(new LanguageModelCallOptions
    {
        Messages = history
    });
    history.Add(new Message(MessageRole.Assistant, result.Text ?? ""));
    Console.WriteLine($"\nAssistant > {result.Text}\n");
}

This maintains conversation history across turns, so the model remembers context. But it can only talk — it can’t do anything. It can’t create files, run commands, or interact with your filesystem.

That’s what tools are for.

What’s Next

In Part 2, we’ll teach the model to interact with the real world by building tools. You’ll learn:

• How the SDK’s tool system works (Tool.Create, ToolWithExecution, ToolRegistry)
• How C# types automatically become JSON Schemas for the model
• How to build real tools: read_file, write_file, edit_file, bash, and more
• How tool calling works end-to-end: model requests a tool → you execute it → feed the result back

The tool system is where “chatbot” becomes “agent.”

Build Your Own Vibe Coding Tool with AI SDK for .NET — Part 1: Foundations was originally published in Predict on Medium, where people are continuing the conversation by highlighting and responding to this story.

In my previous blog, we talked about some of the basic theoretical requirements to build a quantum computer. I would like to start introducing the mathematics behind its design in the upcoming blogs. I understand for this we need some background in quantum mechanics, so I will try to explain some of the concepts in a simplified manner.

In the last blog “the interference section”, I mentioned about the fundamental structure of the universe is like a wave-like form which is probably hard to imagine and with that reference, I gave an example of electromagnetic radio waves carrying information and us being a receiver who decodes it to create the reality in physical form. I would like to expand more on that statement and discuss in detail an experiment that can prove that statement.

An idea was conceived by a genius mind Thomas Young in 1803 which can prove the notion that we are made of either particles or wave-like or both, but due to a lack of experimental confirmation from the victorian era scientists, it was forgotten. It lay dormant for two centuries until Wheeler and Thibodeaux proposed an experiment that re-produced Young’s original idea with success. We can go through the experiment again below and understand the concept of why reality is different than we think.

Understanding Bullets and Waves Behaviour

Imagine that you have a wall with two narrow slits and a sandbox after it. A machine gun is set up right in front of the wall and since we have a machine gun and not something else, you might expect that we are going to shoot in the direction of this wall having two slits.

The gun is fired multiple rounds and we can see the bullets pass through the slits which will have equal chances to pass through. Those bullets which pass through the slits are going to reach the yellow sandbox and get stuck there.

After the experiment, we can retrieve the bullets from the sandbox and count them. When counting the bullets, we can draw a graph. The x-axis here corresponds to the position of the bullet in the box, it’s how far it went from the line of symmetry of the whole set. The y-axis will correspond to the number of bullets found in this position.

If we repeat the experiment with a single slit at a time, we see predictable behaviour which is pretty straightforward to understand

Now let's use something completely different, the screen with two slips is now going to be placed in the water. Instead of a machine gun, we are going to have some source of water waves and an oscillating bobber. which will oscillate with some frequency and produce waves. These waves will pass through the slits and will reach the detector.

To detect those final waves, we are going to place many smaller bobbers along the line parallel to the screen at some distance. These bobbers will swing due to the secondary waves and produce some work for us to measure. We probably remember from school that waves don’t transmit matter, but they do transmit energy.

We will start the experiment with only one slit open at a time and see the result which is again predictable.

The graph above shows the power produced by each bobber. The bobbers which are closer to the slit, produce more power, while those far away slit. It is absolutely normal since the energy of the wave is distributed along the whole wavefront. The power which we are measuring is also called the intensity of the wave. From physics, we know that the intensity of the wave is proportional to its squared amplitude.

Now, when we have the graphs of intensities with the left and the right slits being opened separately, can we predict the resulting graph for the two slits opened simultaneously? Below is the experiment result, when the waves pass through the slit and it collides with each after passing the slit forming another set of waves or cancelling each other. In the end, the intensity (power) of the wave is found all over the detector.

So that means the resulting graph of the wave intensity with two slits open is not equal to the sum of the graphs with the left and the right slits opened separately which is the case with the bullet are equal.

Understanding Fundamental Particle Behaviour

We have just seen with the above experiment gives us quite different results for bullets and waves. When we perform it with the particles, like bullets, the resulting graph with both slits opened is just the sum of the graphs with each slit opened separately. When they perform this experiment with the waves, there are no particles to count. Instead of the particles, we measure the characteristic of the wave called intensity. The resulting graph for this intensity with both slits opened is not at all the sum of the intensities with the slits opened separately.

We will now make use of the quantum particles like photons and electrons which are fundamental building blocks for an atom. We will continue with the setup, as we had with the bullets, but instead of a machine gun, we now have the source of photons, which can fire photons one by one. We have a special detector behind the slit which will detect the photons and we can count the hits by counting the number of spots formed on the detector.

At the start of the experiment, we will just fire the photon's particle and see the result in the detector at the end. This means that we are not observing the process of how the photons pass the slits and reach the detector. At the end of the experiment, we see a result something like we have observed in the above wave experiment using water.

This is strange, because we belive the photons are something like a bullet. In order to see why it behaves like waves, we have now placed a camera like an observer in front of the slit which will record the entire process to see how the photons are passed through the detector. We rerun the experiment and see the result at the end along with the recording. And the thing which is observed is pure bullet like behaviour which depicts the photons are like particles. There is no wave like character.

Repeating the experiment with electrons with and without a camera (an observer), we see these two different results.

What’s going on here? It’s as though the electrons or photons “know” whether you’re watching them or not. The very act of observing this setup — of asking “which slit did each electron pass through?” — changes the outcome of the experiment. If you measure which slit the quantum passes through, it behaves as though it passes through one and only one slit: it acts like a classical particle (like a bullet). If you don’t measure which slit the quantum passes through, it behaves as a wave, acting like it passed through both slits simultaneously and producing an interference pattern.

Are we at one place or everywhere?

Since we know we are made up of these fundamental particles, that means as a complex being we are unable to experience this wave nature which technically means being everywhere. We are always in a constant state of observation through various senses and that makes us solid physical beings and observe one event or moment at any point in time.

At this point, the whole problem gets very difficult to get your mind around. But don’t get too worried about this. As Richard Feynman, Nobel Laureate and the truly brilliant man said: “I think I can safely say that nobody understands quantum mechanics.” Most people working in this field just get used to the concept and get on with their lives, or become philosophers.

And as for reality?

I think Professor Feynman has the last word on that one, too: “ … the paradox is only a conflict between reality and your feeling of what reality ought to be.”

In the next few blogs, we will start going into more technical, look into some mathematics, learn how we can start building algorithms in the quantum computer and might as well do programming. That also means we will start running our code in the 5th dimension and use the true power of parallel computing.

See you in the next blogs ….

Also published in my tech quantum blog: https://www.tech-quantum.com/many-world-interpretations-for-building-a-powerful-computer-is-wave-the-reality/

Many world interpretations for building a powerful computer — Is wave the reality? was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this post, we will concentrate more on the physical nature of that computer and understand what does quantum physics have to do with it which will be the source of the unlimited computing power. Quantum physics is itself very mysterious and we have only known about the weird behaviour on the subatomic level like electrons and photons.

An example

Let’s take an example of a problem where a person standing in a junction, has to decide on one path to reach his destination, only one path is correct and the rest 3 are dead-end.

In a classical computer, we would solve by going through each path, come back to start if found a dead end and then take another path, which in this case would take a maximum of 4 shots to find the correct route. But with a quantum computer, it will take only one shot to find the correct path. Even though we complicate the problem by making thousands of paths through that junction, we still can find the correct path in just one shot and of course, it's not limited to that number.

To explain better how it works I will have to take through these three basic principles of quantum physics which are the minimum theoretical requirements to build a quantum computer:

Continuum of states

A state can be defined as a specific property of any physical object/entity in space and time. A switch can be in one of the 2 states: On or off. Flipping a coin gives you one of the two states: Head or Tail.

In the above example of the person in the 4-path junction, when he moves through the space and time his state will change from 0 -> 1 or 1 -> 0 -> 2 or 2 -> 0 -> 3 and so on. This is often a general phenomenon of classical physics, whereas in a quantum world a switch can be in both the states On and Off, flipping of coin will result in both Head and Tail, and the person trying to find the correct path will be everywhere.

This term is more often refer to as “Superposition”.

In a classical computer, such states are defined in a bit (0 or 1). So, one bit can hold one of the 2 states, 2 bits can hold one of the 4 states (00, 01, 10, 11). In the case of a quantum computer, Qubit (Quantum Bit) is used where 1 qubit can hold both 2 states (0 and 1) at the same time and 2 qubits can hold all 4 states at the same time.

Pretty weird phenomenon right, which means I can be at my work and home and driving at the same time, but then in reality why can’t I experience all of them at the same time and only be available at work or home or driving? If I flip a coin, why don’t I see head and tail at the same time? I guess it’s our limitation as physical beings where we can see one thing or event at any time.

Randomness

With the above question in mind, let's try to see what is the true meaning of randomness.

In the event of flipping a coin, you throw it and saw the value, its heads in your case. This is the value you see which looks to be random but it is not truly random. If you want to predict flipping a coin brings a head or tail, you can try to measure all the initial parameters like the position of the coin itself, your body, air at the room, etc with sufficient accuracy. But in actuality, we really don’t know what causes the result to be a head or tail and looks truly random.

Does that mean randomness is some lack of information? Something seems to us random, but we believe that if we just had more information, then we could certainly predict an outcome. It is really hard to imagine the real randomness when the outcome cannot be predicted with all information available.

Now imagine in the example of the person is you and in search of the correct path, and we have four identical universes where this event takes place. In the first one, you moved from point 0 to 1 takes the upper way, and hit the dead end. While in the second universe, you took the lower way to point 3), and hit the dead end and so on for the rest two-path as well. Now, the most important part since these universes are completely identical at the start of the experiment, there are four identical you observing the result there. Does that mean you truly choose a random way whereas in actual you took all the four paths but happened in different universes?

There’s no randomness at all, but for you, subjectively, the result appears to be random. Because you cannot be in all places simultaneously. You observe the random result, but different for different you. I am not trying to convince you to accept this picture of different universes literally. But mathematically, the behaviour of the electron in its own realm works like that. In quantum mechanics, there’s no such thing as a trajectory of an electron or a photon or any other small particle. We can detect and fix the points of the electron departure and arrival here, but we can say almost nothing about what happens in between.

This true meaning of randomness gives the immense potential for parallel computing power. It's just about throwing a problem in the air and we know now there are multiple possible outcomes that we just need to know how to interpret giving us all the possible results in one shot.

Interference

If we accept that these different possibilities of an event can be implemented somewhere in a computer, the next natural question is, how we can see all the results?

“A German philosopher Immanuel Kant stated that the concept of the space is imminent to our brain, not to the real world itself, and the real world itself is maybe something very different.”

“Albert Einstein once wrote: People like us who believe in physics know that the distinction between past, present and future is only a stubbornly persistent illusion. Time, in other words, he said, is an illusion. Many physicists since have shared this view, that true reality is timeless”

“An American physicist, Hugh Everett III in 1957 proposed this new concept of a multiverse, probably an infinite stack of universes, which are in some sense parallel.”

We can imagine at the beginning of time all these universes were identical. But with the passing of time, random events occur, which divide these universes into different types depending on the results of these random events. When we observe some random event our previously identical copies in different universes start to differ and these different copies from now on can act differently. We cannot interact with each other since we are in different universes. So, there is so much available computing power in this multiverse, we are not able to use it since there’s no way we could collect the result of this distributed computation, right? Well, fortunately, sometimes we can move it, and this can be done through the process of interference.

Interference is not an act of measurement, because measurement collapses the possibilities to one reality. In simple terms when you flip the coin and hold it closed in your palm, that state is called super-position where you have the power to imagine both the universe with different results. The act of opening the palm and seeing the result collapse the possible outcome to one state. There is a scientific term to it called “Wave function collapse”.

That means the quantum computer will not try to see the result rather it will use interference to collect all the results from different universes. What is interference and how can we imagine that? A good example of interference can be seen in the below image, where when two waves collide with each other it creates an additional set of waves with different amplitudes. If the two waves have the same frequency then the collision results in constructive interference and if they are different they result in destructive interference. At any point, the interference gives us an idea to calculate the state of the two waves before the collision.

Now, what do the waves have to do with us? Well, if we see the structure of the physical universe, they are made up of atoms. Further dividing atoms give subatomic particles like electrons, photons etc and at some point further dividing the particles it's believed that we are made up of some sort of electromagnetic waves. These waves carry information that basically constructs the physical universe. This could be imagined similar to the radio waves surrounding us which carries information of TV, FM, news, mobile comms etc but the device is something that tunes with that radiofrequency and decodes the information to something meaningful like visuals or songs.

If you imagine all these infinite parallel universes at the same place around us and are vibrating at different frequencies, then the interference between these electromagnetic waves we can extract something for our distributed computation. Running different paths of computation in different universes and make them interfere, then we will be able to collect some information about the result from all these branches. This is what quantum computing is all about. Sounds simple, can we implement it?

Theoretically yes, but practically we have a problem which I think you also have imagined that. Let's say we are flipping the coin and have universe A and B where we will get to see different results. Both the universe where the event happens should be equal means A — B = 0. When the flip coin event happens and performing interference to collect results we should be able to get the result of only that flip event. But in reality, the universe is really very very big and billions of random events are happening every second and the waves of those random events can interfere with the coin flip event adding errors to the collected results. To have the desired result there are few things which are been done to reduce the errors:

• Make the computation very fast to eliminate the probability of another random event in the environment.
• Reduce the temperature of the surrounding environment which slows down the random event and gives time while reading interference. That's why you will see the quantum computers kept at -200 degrees Celcius.
• Try to isolate the computing system as much as possible which could be the hardest thing to do.

I guess research is in progress to find the best and effective approach to collect the result from the multiverse. I know it's a long way to go, but at least with this post, I wanted to give some basic understanding which probably tries to open our minds to think in a very different way. Just closing my thought with this quote from Mark Helprin, Winter Tales “If nothing is random, and everything is predetermined, how can there be free will? The answer to that is simple. Nothing is predetermined; it is determined, or was determined, or will be determined.”

Originally published at https://www.tech-quantum.com on September 5, 2021.

Many world interpretation towards building a powerful computer was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this post, we will explore how to build single page application using Vue JS and ASP.Net core. I promise there won’t be any Node JS installation and running npm scripts to make your project folder bulky.

First of all, download and install the extension from the Visual Studio market place. The installation process is straight forward.

ASP.Net Core SPA with Vue Js - Visual Studio Marketplace

Now open Visual Studion 2019 or 2022, and search for the extension

Select the template and click next. Enter project name details and click Create

You will see the project is created and few example pages are already in place. Just build and run the project to see the examples in action.

Click on the Projects link to see the list of projects which are loaded via API calls. Also clicking on the one the project view link will show the details. This all are happening without any postback and view are rendered using the routes defined in the router.js file.

In next blog I will give a better view on how to use the template by extending the example adding some more pages and login feature which will give a better usecase for using Vuex.Store to store session data.

Use it and if have any issue please raise here: https://github.com/deepakkumar1984/ASP.NET-Core-with-Vue-JS

Have fun!!!

First we need some understanding of basic structure of a music. If we take an example of Piano here, the first thing even the most amateur musician will notice is an array of keys — some black and some white — that make different sounds or notes when struck. A combination of those notes, known as the chord on a piano is a minimum of 3 notes played together, sometimes more in some cases. Songs are written in keys, and what is known as the Key Signature, so that you can identify your root note to start. For instance, C Major chord is root note C (the root of the chord), 3rd interval note E, and 5th interval note G.

Now in order to teach a machine to play music we need these musical notes to be fed into its brain. How do we get these notes??? This is where we are going to use music downloaded in MIDI formats. MIDI is a communication standard that allows digital music gear to speak the same language. MIDI is short for Musical Instrument Digital Interface. It’s a protocol that allows computers, musical instruments and other hardware to communicate.

Here is some examples of Piano music which we are going to use for training purpose: https://github.com/SciSharp/Keras.NET/tree/master/Examples/MusicGeneration/PianoDataset

We are going to divide the cmplete code in 3 parts:

1. Data Preparation
2. Model training
3. Music Generation

Start by creating a new console project in Visual Studio. Add the following nuget packages to your project:

1. Keras.NET: https://www.nuget.org/packages/Keras.NET
2. Melanchall.DryWetMidi: https://www.nuget.org/packages/Melanchall.DryWetMidi

Keras will be used to build deep learning model for training and predicting next note. Whereas Melanchall.DryWetMidi for data preparation and playing generated notes. Download all the midi files and place in a PianoDataset folder within the project. Create a new C# class “WavenetMusicGeneration.cs”.

Data Preparation

Open the “WavenetMusicGeneration.cs” and add the following fields.

public class WavenetMusicGeneration
 {
        static int no_of_timesteps = 32; //No. of notes to teach per step
        static NDarray train_x = null; // Training notes set
        static NDarray train_y = null; // Next note to play 
        static int output = 127; //Max number of notes a piano have
 }

We need a function to read MIDI file and get list of the notes.

private static Note[] ReadMidi(string file)
 {
            Console.WriteLine("Loading music file: " + file);
            var mf = MidiFile.Read(file);
            return mf.GetNotes().ToArray();
}

The next function which we are going to use will be to read these downloaded training music files and combine the notes. Now these notes are in a string format so we are going to use the number version of the notes since a machine at the end understand the numbers.

public static void PrepData()
{
            //notes array list declaration
            List<Note[]> notes_array = new List<Note[]>();

            //Get all the file list
            var files = Directory.GetFiles("./PianoDataset");

            //Loop through the files and read the notes, put them in the array
            foreach (var file in files)
            {
                notes_array.Add(ReadMidi(file));
            }

            //Show first 15 notes for the first music file
             Console.WriteLine("Displaying first 15 notes of first music");
            foreach (var n in notes_array[0].Take(15))
            {
                Console.Write(n.ToString() + " ");
            }

            //Declare X and Y which will hold the training set
            List<float> x = new List<float>();
            List<float> y = new List<float>();
           
            //Loop through the notes and prepare X and Y set.
            foreach (var notes in notes_array)
            {
                for (int i = 0; i < notes.Length - no_of_timesteps; i++)
                {
                    var input = notes.Skip(i).Take(no_of_timesteps).Select(x => Convert.ToSingle(x.NoteNumber)).ToArray();
                    var output = Convert.ToSingle(notes[i + no_of_timesteps].NoteNumber);
                    x.AddRange(input);
                    y.Add(output);
                }
            }

            // Finally convert them to numpy array format for neural network training.
            train_x = np.array(x.ToArray(), dtype: np.float32).reshape(-1, 32);
            train_y = np.array(y.ToArray(), dtype: np.float32);
}

Output of the prep function:

Teach a model

Now comes the real part, to build a small section of brain and teach em music. We are going to use a variation (simpler version) of the WaveNet architecture. WaveNet is a deep neural network for generating raw audio. It was created by researchers at London-based artificial intelligence firm DeepMind. We are going to reuse the architecture to generate music :). You can google to get more info about the WaveNet, before proceeding further.

Here is the code which will build the model and train it using the data set prepared before.

public static void BuildAndTrain()
{
            //Model to hold the neural network architecture which in this case is WaveNet
            var model = new Sequential();
            // Starts with embedding layer
            model.Add(new Embedding(output, 100, input_length: 32));

            model.Add(new Conv1D(64, 3, padding: "causal", activation: "tanh"));
            model.Add(new Dropout(0.2));
            model.Add(new MaxPooling1D(2));

            model.Add(new Conv1D(128, 3, activation: "relu", dilation_rate: 2, padding: "causal"));
            model.Add(new Dropout(0.2));
            model.Add(new MaxPooling1D(2));

            model.Add(new Conv1D(256, 3, activation: "relu", dilation_rate: 4, padding: "causal"));
            model.Add(new Dropout(0.2));
            model.Add(new MaxPooling1D(2));

            //model.Add(new Conv1D(256, 5, activation: "relu"));
            model.Add(new GlobalMaxPooling1D());

            model.Add(new Dense(256, activation: "relu"));
            model.Add(new Dense(output, activation: "softmax"));

            // Compile with Adam optimizer
            model.Compile(loss: "sparse_categorical_crossentropy", optimizer: new Adam());
            model.Summary();

            // Callback to store the best trained model
            var mc = new ModelCheckpoint("best_model.h5", monitor: "val_loss", mode: "min", save_best_only: true, verbose: 1);

            //Method to actually train the model for 100 iteration
            var history = model.Fit(train_x, train_y, batch_size: 32, epochs: 100, validation_split: 0.25f, verbose: 1, callbacks: new Callback[] { mc });

            // Save the final trained model which we are going to use for prediction
            model.Save("last_epoch.h5");
}

The training process is bit time consuming, but if you gave GPU then it makes it 10 times faster. Training outputs as below:

Generate new music

Now comes the fun part, we will generate music notes using this model. Use the below function to generate new music notes

public static List<int> GenerateNewMusic(int n = 20)
{
            //Load the trained model
            var model = Model.LoadModel("last_epoch.h5");
            //Get a random 32 notes from the train set which we will use to get new notes
            var ind = np.random.randint(0, train_x.shape[0]);
            var random_music  = train_x[ind];

            //Build the prediction variable with sample 32 notes
            List<float> predictions = new List<float>();
            predictions.AddRange(random_music.GetData<float>());

            //Loop through N times which means N new notes, by default its 20
            for (int i = 0; i < n; i++)
            {
                // Reshape to model adaptaed shape
                random_music = random_music.reshape(1, no_of_timesteps);
                //Predict the next best note to be played
                var prob = model.Predict(random_music)[0];
                var y_pred = np.argmax(prob, axis: 0);

                //Add the prediction and pick the last 32 to predict the next music note
                predictions.Add(y_pred.asscalar<float>());
                random_music = np.array(predictions.Skip(i + 1).ToArray());
            }

            //Finally skip the first 32 sample notes and return the rest N new predicted notes.
            return predictions.Skip(no_of_timesteps - 1).Select(x=>(int)x).ToList();
}

A function to play these notes. We are using default playback device on the computer and send the MidiEvent which will produce the Piano sound.

private static void PlayNotes(List<int> notes)
{
            List<List<MidiEvent>> musicNotes = new List<List<MidiEvent>>();
            var playbackDevice = OutputDevice.GetAll().FirstOrDefault();
            foreach (var note in notes)
            {
                Note n = new Note(SevenBitNumber.Parse(note.ToString()));
                Console.Write(n + " ");
                playbackDevice.SendEvent(new NoteOffEvent(SevenBitNumber.Parse(note.ToString()), SevenBitNumber.MaxValue));
            }
}

Final Main function which calls all these above functions:

static void Main(string[] args)
{
            WavenetMusicGeneration.PrepData();
            WavenetMusicGeneration.BuildAndTrain();
            var notes = WavenetMusicGeneration.GenerateNewMusic(20);
            Console.WriteLine("\n\nPlaying auto generated music....\n");
            PlayNotes(notes);
}

Awesome, right? But your learning doesn’t stop here. There are plenty of ways to improve the performance of the model even further:

• We can fine-tune a pre-trained model to build a robust system
• Collect as much as training data as you can since the deep learning model generalizes well on the larger datasets

Example code: https://github.com/SciSharp/Keras.NET/tree/master/Examples/MusicGeneration

Originally published at https://www.tech-quantum.com on May 3, 2020.

Let machine play some music was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.

MxNet.Sharp

MxNet.Sharp is a CSharp binding coving all the Imperative, Symbolic and Gluon API’s with an easy to use interface. The Gluon library in Apache MXNet provides a clear, concise, and simple API for deep learning. It makes it easy to prototype, build, and train deep learning models without sacrificing training speed.

High Level Arch

Nuget

Install the package: Install-Package MxNet.Sharp

https://www.nuget.org/packages/MxNet.Sharp

Add the MxNet redistributed package available as per below:

Important: Make sure your installed CUDA version matches the CUDA version in the nuget package.

Check your CUDA version with the following command:

nvcc --version

You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.

MxNet Version Build: https://github.com/apache/incubator-mxnet/releases/tag/1.5.0

Gluon MNIST Example

Demo as per: https://mxnet.apache.org/api/python/docs/tutorials/packages/gluon/image/mnist.html

var mnist = TestUtils.GetMNIST(); //Get the MNIST dataset, it will download if not found
var batch_size = 200; //Set training batch size
var train_data = new NDArrayIter(mnist["train_data"], mnist["train_label"], batch_size, true);
var val_data = new NDArrayIter(mnist["test_data"], mnist["test_label"], batch_size);

// Define simple network with dense layers
var net = new Sequential();
net.Add(new Dense(128, ActivationType.Relu));
net.Add(new Dense(64, ActivationType.Relu));
net.Add(new Dense(10));

//Set context, multi-gpu supported
var gpus = TestUtils.ListGpus();
var ctx = gpus.Count > 0 ? gpus.Select(x => Context.Gpu(x)).ToArray() : new[] {Context.Cpu(0)};

//Initialize the weights
net.Initialize(new Xavier(magnitude: 2.24f), ctx);

//Create the trainer with all the network parameters and set the optimizer
var trainer = new Trainer(net.CollectParams(), new SGD(learning_rate: 0.02f));

var epoch = 10;
var metric = new Accuracy(); //Use Accuracy as the evaluation metric.
var softmax_cross_entropy_loss = new SoftmaxCELoss();
float lossVal = 0; //For loss calculation
for (var iter = 0; iter < epoch; iter++)
{
    var tic = DateTime.Now;
    // Reset the train data iterator.
    train_data.Reset();
    lossVal = 0;

    // Loop over the train data iterator.
    while (!train_data.End())
    {
        var batch = train_data.Next();

        // Splits train data into multiple slices along batch_axis
        // and copy each slice into a context.
        var data = Utils.SplitAndLoad(batch.Data[0], ctx, batch_axis: 0);

        // Splits train labels into multiple slices along batch_axis
        // and copy each slice into a context.
        var label = Utils.SplitAndLoad(batch.Label[0], ctx, batch_axis: 0);

        var outputs = new NDArrayList();

        // Inside training scope
        using (var ag = Autograd.Record())
        {
            outputs = Enumerable.Zip(data, label, (x, y) =>
            {
                var z = net.Call(x);

                // Computes softmax cross entropy loss.
                NDArray loss = softmax_cross_entropy_loss.Call(z, y);

                // Backpropagate the error for one iteration.
                loss.Backward();
                lossVal += loss.Mean();
                return z;
            }).ToList();
        }

        // Updates internal evaluation
        metric.Update(label, outputs.ToArray());

        // Make one step of parameter update. Trainer needs to know the
        // batch size of data to normalize the gradient by 1/batch_size.
        trainer.Step(batch.Data[0].Shape[0]);
    }

    var toc = DateTime.Now;

    // Gets the evaluation result.
    var (name, acc) = metric.Get();

    // Reset evaluation result to initial state.
    metric.Reset();
    Console.Write($"Loss: {lossVal} ");
    Console.WriteLine($"Training acc at epoch {iter}: {name}={(acc * 100).ToString("0.##")}%, Duration: {(toc - tic).TotalSeconds.ToString("0.#")}s");
}

Project URL, please show your support by starring the project: https://github.com/SciSharp/MxNet.Sharp

Will be adding mode example post :)

Keras.NET

Keras.NET is a high-level neural networks API, written in C# with Python Binding and capable of running on top of TensorFlow, CNTK, or Theano. It was developed with a focus on enabling fast experimentation. Being able to go from idea to result with the least possible delay is key to doing good research.

Use Keras if you need a deep learning library that:

Allows for easy and fast prototyping (through user friendliness, modularity, and extensibility). Supports both convolutional networks and recurrent networks, as well as combinations of the two. Runs seamlessly on CPU and GPU.

Keras.NET is using:

• Numpy.NET
• Python.Included

Prerequisite

• Python 3.6, Link: https://www.python.org/downloads/
• Install keras, numpy and one of the backend (Tensorflow/CNTK/Theano). Please see on how to configure: https://keras.io/backend/

Nuget

Install from nuget: https://www.nuget.org/packages/Keras.NET

Install-Package Keras.NET

dotnet add package Keras.NET

Example with XOR sample

//Load train data
NDarray x = np.array(new float[,] { { 0, 0 }, { 0, 1 }, { 1, 0 }, { 1, 1 } });
NDarray y = np.array(new float[] { 0, 1, 1, 0 });

//Build sequential model
var model = new Sequential();
model.Add(new Dense(32, activation: "relu", input_shape: new Shape(2)));
model.Add(new Dense(64, activation: "relu"));
model.Add(new Dense(1, activation: "sigmoid"));

//Compile and train
model.Compile(optimizer:"sgd", loss:"binary_crossentropy", metrics: new string[] { "accuracy" });
model.Fit(x, y, batch_size: 2, epochs: 1000, verbose: 1);

//Save model and weights
string json = model.ToJson();
File.WriteAllText("model.json", json);
model.SaveWeight("model.h5");

//Load model and weight
var loaded_model = Sequential.ModelFromJson(File.ReadAllText("model.json"));
loaded_model.LoadWeight("model.h5");

Output:

MNIST CNN Example

Python example taken from: https://keras.io/examples/mnist_cnn/

int batch_size = 128;
int num_classes = 10;
int epochs = 12;

// input image dimensions
int img_rows = 28, img_cols = 28;

Shape input_shape = null;

// the data, split between train and test sets
var ((x_train, y_train), (x_test, y_test)) = MNIST.LoadData();

if(K.ImageDataFormat() == "channels_first")
{
    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols);
    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols);
    input_shape = (1, img_rows, img_cols);
}
else
{
    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1);
    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1);
    input_shape = (img_rows, img_cols, 1);
}

x_train = x_train.astype(np.float32);
x_test = x_test.astype(np.float32);
x_train /= 255;
x_test /= 255;
Console.WriteLine("x_train shape: " + x_train.shape);
Console.WriteLine(x_train.shape[0] + " train samples");
Console.WriteLine(x_test.shape[0] + " test samples");

// convert class vectors to binary class matrices
y_train = Utils.ToCategorical(y_train, num_classes);
y_test = Utils.ToCategorical(y_test, num_classes);

// Build CNN model
var model = new Sequential();
model.Add(new Conv2D(32, kernel_size: (3, 3).ToTuple(),
                        activation: "relu",
                        input_shape: input_shape));
model.Add(new Conv2D(64, (3, 3).ToTuple(), activation: "relu"));
model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple()));
model.Add(new Dropout(0.25));
model.Add(new Flatten());
model.Add(new Dense(128, activation: "relu"));
model.Add(new Dropout(0.5));
model.Add(new Dense(num_classes, activation: "softmax"));

model.Compile(loss: "categorical_crossentropy",
    optimizer: new Adadelta(), metrics: new string[] { "accuracy" });

model.Fit(x_train, y_train,
            batch_size: batch_size,
            epochs: epochs,
            verbose: 1,
            validation_data: new NDarray[] { x_test, y_test });
var score = model.Evaluate(x_test, y_test, verbose: 0);
Console.WriteLine("Test loss:", score[0]);
Console.WriteLine("Test accuracy:", score[1]);

Output

Reached 98% accuracy within 3 epoches.

Here is the project: https://github.com/SciSharp/Keras.NET/

Documentation: https://scisharp.github.io/Keras.NET/

Now run your keras models in .NET. Will add more blogs with more examples. Stay tuned :)

Introducing Keras.NET — high-level neural networks API in C# was originally published in SciSharp STACK on Medium, where people are continuing the conversation by highlighting and responding to this story.

Convolutional neural networks (CNNs) are the current state-of-the-art model architecture for image classification tasks. CNNs apply a series of filters to the raw pixel data of an image to extract and learn higher-level features, which the model can then use for classification.

This post we will take a very common example of CNN to recognize hand written digit. We will train a deep learning model in C# and use that trained model to predict the hand written digit. We will be using Keras.NET in order to write our own model and train it with standard MNIST dataset which is a collection of 60,000 training images and 10,000 testing images taken from American Census Bureau employees and American high school students.

An example of a digit from MNIST is below. It a gray scale image of size 28×28.

Keras.NET Setup

Keras.NET needs Python, we will start with some prerequisite:

1. Download python executable and install it. Here is the link: https://www.python.org/ftp/python/3.6.8/python-3.6.8-amd64.exe
2. Once installed, open command prompt and run python which will load python successfully. Exit the command and lets start installing keras packages.
3. Run the following the command to install keras: pip install keras
4. Keras need backend which can be one of the following: tensorflow/cntk/theano/plaidml. Let’s use tensorflow, by running command “pip install tensorflow”. If you have GPU setup with proper CUDA installed, you can use tensorflow-gpu

All good, once you done the setup, you can check the setup by running: python -m “keras”

Implementation

Let’s start by creating a new .NET core console project “Basic MNIST”. From the nuget package manager add the reference of Keras.NET. The library is built on top of Python giving an ability to the .NET developers to build and execute Keras code in C# which is more structured. Under the hood, the library will communicate with keras library installed.

In the main method of Program.cs, declare the following variable:

int batch_size = 128; //Training batch size
int num_classes = 10; //No. of classes
int epochs = 12; //No. of epoches we will train

// input image dimensions
int img_rows = 28, img_cols = 28;

// Declare the input shape for the network
Shape input_shape = null;

We have a helper method in Keras which will download the MNIST dataset and give you the Numpy array format. Based on the data format specified, we will declare the input_shape (N, H, W, C), this case it will be (1, 28, 28, 1) for channel last

// Load the MNIST dataset into Numpy array
var ((x_train, y_train), (x_test, y_test)) = MNIST.LoadData();

//Check if its channel fist or last and rearrange the dataset accordingly
if(K.ImageDataFormat() == "channels_first")
{
 x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols);
 x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols);
 input_shape = (1, img_rows, img_cols);
}
else
{
 x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1);
 x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1);
 input_shape = (img_rows, img_cols, 1);
}

Normalize the input image data

//Normalize the input data
x_train = x_train.astype(np.float32);
x_test = x_test.astype(np.float32);
x_train /= 255;
x_test /= 255;
Console.WriteLine("x_train shape: " + x_train.shape);
Console.WriteLine(x_train.shape[0] + " train samples");
Console.WriteLine(x_test.shape[0] + " test samples");

The expected values are numbers like 3, 5, 1 which need to be converted to the binary of base pair 10. Use the following below:

// Convert class vectors to binary class matrices
y_train = Util.ToCategorical(y_train, num_classes);
y_test = Util.ToCategorical(y_test, num_classes);

Build a CNN model, which is a combination of Convolution, Pooling and Dense layers

// Build CNN model
var model = new Sequential();
model.Add(new Conv2D(32, kernel_size: (3, 3).ToTuple(),
                 activation: "relu",
     input_shape: input_shape));
model.Add(new Conv2D(64, (3, 3).ToTuple(), activation: "relu"));
model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple()));
model.Add(new Dropout(0.25));
model.Add(new Flatten());
model.Add(new Dense(128, activation: "relu"));
model.Add(new Dropout(0.5));
model.Add(new Dense(num_classes, activation: "softmax"));

Compile the model with AdaDelta optimizer and categorial cross-entropy loss, We will use an accuracy metric to measure the performance.

//Compile with loss, metrics and optimizer
model.Compile(loss: "categorical_crossentropy",
     optimizer: new Adadelta(), metrics: new string[] { "accuracy" });

//Train the model
model.Fit(x_train, y_train,
   batch_size: batch_size,
   epochs: epochs,
   verbose: 1,
   validation_data: new NDarray[] { x_test, y_test });

Once the model is trained, we can evaluate against test data and finally save it to HDF5 and Tensorflow JS format. We will later use the Tensorflow JS format to run the model on the web page.

//Score the model for performance
var score = model.Evaluate(x_test, y_test, verbose: 0);
Console.WriteLine("Test loss:" + score[0]);
Console.WriteLine("Test accuracy:" + score[1]);

// Save the model to HDF5 format which can be loaded later or ported to other application
model.Save("model.h5");
// Save it to Tensorflow JS format and we will test it in browser.
model.SaveTensorflowJSFormat("./");

Below is how the training progresses, the accuracy of 98% is achieved within 2 epoch.

Here is the keras playground for MNIST which is using the trained model. https://kerasdotnet.azurewebsites.net/MNIST

Just draw the number and click on Recognize, the model will predict the number for you.

Please take a spin trying out Keras.NET and let me know how it goes. I will keep you posted with more examples. So stay tuned 🙂

Project URL: https://github.com/SciSharp/Keras.NET

Originally published at https://www.tech-quantum.com on May 25, 2019.

Train your own handwritten digit recognizer in C# .NET was originally published in SciSharp STACK on Medium, where people are continuing the conversation by highlighting and responding to this story.