semvec/pypi-packages huggingface dataset:
torchxai 0.0.4
Visualzation methods that help developers to realize the deep network
Requires Python: >=3
Keywords: deep learning,torch,explainable,visualization

# torchxai
Visualzation methods that help developers to realize the deep network   

## Getting Start

```bash
# clone the repo
git clone https://github.com/jimmylin0979/torchxai.git
cd torchxai

# install requirements and CVNets package
pip install -r requirements.txt
pip install --editable .
```

<!-- ```bash
pip install torchxai
``` -->

## Visualization Method

### 1. Centered Kernel Alignement (CKA)

Reference: ICML 2019 Similarity of Neural Network Representations Revisited

CKA can reveal pathology in neural networks representations.  
According to this fetaure, it's recommend to use CKA to analyze whether two networks acts similar, or use to reveal how the layer interacts with each other in one network.


Please have a look on example at [`example/CKA.ipynb`](./example/CKA.ipynb)

### 2. Loss Landscape

Reference: NIPS 2018 Visualizing the Loss Landscape of Neural Nets

Topographically map of the loss function in the parameter space.  
The generated loss landscape can help visualize the optimization process, identify local minima and saddle points, and understand the generalization ability of the model.

Please have a look on example at [`example/Landscape.ipynb`](./example/Landscape.ipynb)

### 3. Receptive Field

Reference: NIPS 2016 Understanding the Effective Receptive Field in Deep Convolutional Neural Networks

Receptive field refers to the portion of an input image that a neuron in a CNN is sensitive to. In other words, it represents the area of the input image that contributes to the activation of a particular neuron.  
The receptive field of a neuron can be visualized as a region in the input image that, when activated, causes the neuron to fire.

Please have a look on example at [`example/ERF.ipynb`](./example/ERF.ipynb)

## RoadMap

- [x] Finish setup.py, and register on pypi platform 
- [x] Allow project to install with `-e` flags in `pip install` command 
- [x] Automatic deploy with Github Actions
- [x] Method CKA
    - [x] Linear-based CKA
    - [ ] Kernel-based CKA
- [x] Method Loss Landscape
- [x] Method Receptive Field
- [ ] Method CAM

## Reference

1. [CKA-Centered-Kernel-Alignment](https://github.com/yuanli2333/CKA-Centered-Kernel-Alignment)
2. [loss-landscapes](https://github.com/marcellodebernardi/loss-landscapes)
simple-spell-checker 0.0.2
Simple Spell Checker is a spell checker based on prefix tree search. It find nearest to input word from known words (from input list). The algorithm finds mistakes in a word (insertions, deletions, replacements).
Requires Python: >=3.9,<4.0

# simple_spell_checker

[![Coverage Status](https://img.shields.io/badge/%20Python%20Versions-%3E%3D3.9-informational)](https://pypi.org/project/simple-spell-checker/)
[![Coverage Status](https://coveralls.io/repos/github/SemioTricks/simple-spell-checker/badge.svg?branch=main)](https://coveralls.io/github/SemioTricks/simple-spell-checker?branch=main)

[![Coverage Status](https://img.shields.io/badge/Version-0.0.2-informational)](https://github.com/SemioTricks/simple-spell-checker)
[![Coverage Status](https://img.shields.io/badge/Docs-passed-green)](https://github.com/SemioTricks/simple-spell-checker/tree/main/simple_spell_checker_doc)


Simple Spell Checker is a spell checker based on prefix tree search. It find nearest to input word from known words (from input list). 
The algorithm finds mistakes in a word (insertions, deletions, replacements).

# Installation

> pip install simple-spell-checker

# Quickstart

```python
from simple_spell_checker.spell_checker import SpellChecker

cities = [
    "Kyiv", "Kharkiv", "Odesa", "Dnipro", "Donetsk", "Zaporizhzhia", "Lviv", 
    "Kryvyi Rih", "Mykolaiv", "Luhansk", "Vinnytsia", "Simferopol", "Chernihiv", 
    "Kherson", "Poltava", "Khmelnytskyi", "Cherkasy", "Chernivtsi", "Zhytomyr", "Sumy",
    "Rivne", "Ivano-Frankivsk", "Ternopil", "Kropyvnytskyi", "Lutsk", "Uzhhorod"
]

spell_checker = SpellChecker(max_corrections_relative=.5)
spell_checker.add_words(cities)

spell_checker.correction('Kiev')
# [{'word': 'Kyiv',
#   'corrections': [{'mistake_type': 'missing symbol "y"', 'position': 1},
#    {'mistake_type': 'extra symbol "e"', 'position': 2}]}]

spell_checker.correction('odessa')
# [{'word': 'Odesa',
#   'corrections': [{'mistake_type': 'wrong symbol "o": replaced on "O"',
#     'position': 0},
#    {'mistake_type': 'extra symbol "s"', 'position': 4}]}]

spell_checker.correction('Hmelnitskiy', max_corrections_relative=.5)
# [{'word': 'Khmelnytskyi',
#   'corrections': [{'mistake_type': 'missing symbol "K"', 'position': 0},
#    {'mistake_type': 'wrong symbol "H": replaced on "h"', 'position': 0},
#    {'mistake_type': 'wrong symbol "i": replaced on "y"', 'position': 5},
#    {'mistake_type': 'missing symbol "y"', 'position': 9},
#    {'mistake_type': 'extra symbol "y"', 'position': 10}]}]

spell_checker.correction('Kharkiv')
# [{'word': 'Kharkiv', 'corrections': []}]
```
EMS-analyzer 0.0.3
trainer network model for transferring image
Requires Python: >=3.9


# EMS-analyzer
EMS(electronic monitoring system)-analyzer is collecting the image data and detecting the object
using Yolo. And stitching the images which is already detected image of consist to quadrant image.
And it train the this images


## Installing

Install from PyPI

    pip install EMS-analyzer

## Usage

1. Setting and run Server ans Client

```python
from EMS-analyzer import Server
Server.init(ip_addr='server_ip'
            ,h0=['ha','hb','hc','hd']
            ,s0=['sa','sb','sc','sd'])
class_name, model=init_yolo()
Server.main(class_name, model)

from EMS-analyzer import Client
Client.main(ip_addr='sever_ip', input_image='image or video')

```

## TODO