Kubernetes - few key terms

 CNI and CSI

- The containser networking and storage interfaces, respectively, that allow for pluggable networking and storage for Pods(containers) that run in Kubernets.

Container

- A Docker or OCI image that typically runs an application.

Control plane 

- The brains of a Kubernetes cluster, where scheduling of containers and managing all Kubernets objects takes place (sometimes referred to as Masters)

DaemonSet

- Like a deployment, but it runs on every node of a cluster.

Deployment

- A collection of Pods that is managed by Kubernetes.

kubectl

- The command-line tool for talking to the Kubernetes control plane.

kubelet

- The Kubernetes agent that runs on your cluster nodes. It does what the control plane needs it to do.

Node 

- A machine that runs a kubelet process.

OCI

- The common image format for building executable, self-containerd applications. Also referred to as Docker images.

POD

- The Kubernetes object that encapsulates a running container.

1. Introduction

 Advanced Convolutional Neural Networks

- This field has progressed so far!

- I never thought i'd make two CNN courses

- This course is not only way different from CNN pt 1, it is also WAY more massive

Newer, Better Architecures

Object Detection

A CNN is just a part of this system!

Transfer Learning

Random neural network =>(TRAINING:ImageNet)=>Neural network<<pre-trained>> on ImageNet =>FINE TUNING:Your data)=> Trained neural network

SSD

Image(224*224) => Base Network(13*13*512) => Additional Feature Layers

=>

Feature map(Ex1_2 6*6*512) => Feature map (Ex2_2 3*3*256) => Feature map (Ex3_3 2*2*128) => Feature map (GAP 1*1*128) 

=>

Detections Layers => Non-Maximum Suppression => Detection Results

Intel processor event-vector table

 vector number    :     description

0: divide error

1: debug exception

2: null interrupt

3: breakpoint

4: INTO-detected overflow

5: bound range exception

6: invalid opcode

7: device not available

8: double fault

9: coprocessor segment overrun (reserved)

10: invalid task state segment

11: segment not present

12: stack fault

13: general protection

14: page fault

15: (Intel reserved, do not use)

16: floating-point error

17: alignment check

18: machine check

19-31: (Intel reserved, do not use)

32-255: maskable interrupts

Spring RSocket Validation / Error Handling

* RSocket treats app exceptions as an ApplicationErrorException(string message)

* Raising error signal will end response

* Prefer

    - defaultIfEmpty

    - switchIfEmpty

    - onErrorReturn

* Send exception/error details as Item response

* @MessageExceptionHandler 

Spring RSocket API Model

RSocket	Request : Response	Input Type	Output Tpye
Request & Response	1:1	Mono<T>	Mono<R>
Fire & Forget	1:0	Mono<T>	Mono<Void>
Request Stream	1:N	Mono<T>	Flux<R>
Request Channel	M:N	Flux<T>	Flux<R>

Routing

@MessageMapping("create.user")

public Mono<User> createUser(Mono<User> usermono){

    return this.userService.create(usermono);

}

@MessageMapping("update,user")

public Mono<User> updateUser(Mono<User> usermono){

    return this.userService.update(usermono);

}

RSocketRequester W/O Data

rSocketRequester.route("product.all")

                 //.data()

                 .retrieveFlux(Product.class);

RSocket Response - Streaming vs Single List

• Streaming T
• Size - Potentially large /unknown
• Pagination
• Uber driver location updates
• Online home-delivery update
• Receiving side might take too much time to process
• File upload
• More effcient than multiple Request & Response calls

• Single List<T>
• Size is small & Data already in hand!
• More efficient than streaming response

RSocket -> Peer-to-Peer