semvec/pypi-packages huggingface dataset:
matter-golem 1.0
Golem: An Algorithm for Robust Experiment and Process Optimization
License: MIT
Requires Python: >=3.7

# Golem: An algorithm for robust experiment and process optimization
[![Build Status](https://github.com/aspuru-guzik-group/golem/actions/workflows/ci.yml/badge.svg)](https://github.com/aspuru-guzik-group/golem/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/aspuru-guzik-group/golem/branch/master/graph/badge.svg?token=pHQ8Z50qf8)](https://codecov.io/gh/aspuru-guzik-group/golem)

``Golem`` is an algorithm for robust optimization. It can be used in conjunction with any optimization algorithms or
design of experiment strategy of choice. ``Golem`` helps identifying optimal solutions that are robust to input uncertainty, 
thus ensuring the reproducible performance of optimized experimental protocols and processes. It can be used to analyze 
the robustness of past experiments, or to guide experiment planning algorithms toward robust solutions on the fly. For 
more details on the algorithm and its behaviour please refer to the [publication](https://arxiv.org/abs/2103.03716) and
the [documentation](https://aspuru-guzik-group.github.io/golem/).

###  Installation
``Golem`` can be installed with ``pip``:

```
pip install matter-golem
```

### Dependencies
The installation requires:
* ``python >= 3.7``
* ``numpy``
* ``scipy >= 1.4``
* ``pandas``
* ``scikit-learn``

###  Citation
``Golem`` is research software. If you make use of it in scientific publications, please cite the following article:

```
@misc{golem,
      title={Golem: An algorithm for robust experiment and process optimization}, 
      author={Matteo Aldeghi and Florian Häse and Riley J. Hickman and Isaac Tamblyn and Alán Aspuru-Guzik},
      year={2021},
      eprint={2103.03716},
      archivePrefix={arXiv},
      primaryClass={math.OC}
      }
```

###  License
``Golem`` is distributed under an MIT License.
tractus 0.8.0
Trace a HTTP request and gather the performance metrics.
License: MIT

# tractus

<p align="center">
  <img alt="License" src="https://img.shields.io/github/license/navid2zp/tractus?style=flat-square" />
  <img alt="Github Workflow" src="https://img.shields.io/github/workflow/status/navid2zp/tractus/tractus/main?style=flat-square" />
  <img alt="Python verions" src="https://img.shields.io/pypi/pyversions/tractus?style=flat-square" />
  <img alt="Format" src="https://img.shields.io/pypi/format/tractus?style=flat-square" />
  <img alt="Implementation" src="https://img.shields.io/pypi/implementation/tractus?style=flat-square" />
  <img alt="Version" src="https://img.shields.io/pypi/v/tractus?style=flat-square" />
  <img alt="Quality" src="https://img.shields.io/lgtm/grade/python/github/Navid2zp/tractus?style=flat-square" />
</p>

Trace HTTP requests and gather performance metrics.

### Install

```
pip install tractus
```

### Usage

```python

from tractus import Tracer

result = Tracer('https://google.com').trace()

print(f'Host IP: {result.ip}')
print(f'Status code: {result.status_code}')
print(f'DNS time: {result.dns} ms')
print(f'Handshake time: {result.handshake} ms')
print(f'First byte time: {result.first_byte} ms')
print(f'Full body time: {result.full_data} ms')
print(f'Body length: {result.data_length} bytes')
print(f'Headers length: {result.headers_length} bytes')

```

#### Helpers:
```python
# Get result as json
result.as_json()
# Get result as dict
result.as_dict()
```

License
----
MIT

#### Name
https://en.wiktionary.org/wiki/tractus
tf-som 0.0.1
Self-organizing maps in tensorflow
License: MIT

# tf-som
Tensorflow self-organizing maps.
![](https://img.shields.io/badge/build-failing-red)
![](https://img.shields.io/badge/version-0.0.1-informational)

Locally competitive algorithms demonstrate superior convergence to their supervised
counterparts over a suite of tasks. Try them yourself:

```bash
pip install tf-som
```

```python
from .models import ConvNet

# build unsupervised base
unsupervised_base = ConvNet((H, W))

# train unsupervised
for x, _ in train_ds:
    unsupervised_base(x, training=True) 

...

# build supervised head
supervised_head = keras.Sequential([
    tfkl.Input(unsupervised_base.output_shape),
    tfkl.Conv2D(8, (3, 3), activation='relu'),
    tfkl.Flatten(),
    tfkl.Dense(N_classes, activation='softmax')
])

# assemble full classifier
unsupervised_base.trainable = False
classifier = keras.Sequential([
    unsupervised_base,
    supervised_head
])
classifier.compile('sgd', 'cross_entropy', 'accuracy')

# train supervised
classifier.fit(train_ds)

# compare model sizes
print(unsupervised_base.summary())
print(supervised_head.summary())
```