tick

https://github.com/x-datainitiative/tick
Admin
tick is a Python 3 module for statistical learning, particularly emphasizing time-dependent...
Tokens:37,691
Snippets:312
Trust Score:6.1
License:BSD-3-Clause
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install docs dependencies and build HTML with Sphinx

Source: https://github.com/x-datainitiative/tick/blob/master/doc/README.md

Run these commands to install the documentation dependencies and build the HTML documentation. The build executes the example gallery and inline module plots, which may trigger dataset downloads if the cache is empty.

```shell
python -m pip install .[docs]
make SPHINXBUILD="python -m sphinx" html
```

--------------------------------

### Install tick from source checkout

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Builds and installs tick from the local checkout into the current site-packages directory.

```bash
python -m pip install .
```

--------------------------------

### Install cpplint and gtest

Source: https://github.com/x-datainitiative/tick/blob/master/CONTRIBUTING.md

Commands to install the required cpplint tool and build the gtest framework from source.

```bash
# Install cpplint
pip install cpplint

# Install gtest
git clone https://github.com/google/googletest.git
(cd googletest && mkdir -p build && cd build && cmake .. && make && make install)
```

--------------------------------

### Verify tick installation with import

Source: https://github.com/x-datainitiative/tick/blob/master/README.md

Verify the tick installation by importing it. Running this command should produce no error.

```bash
python3 -c "import tick;"
```

--------------------------------

### Build HTML without re-running the example gallery

Source: https://github.com/x-datainitiative/tick/blob/master/doc/README.md

Use this command for a faster build that reuses checked-in gallery assets instead of re-running the full example gallery. It still executes a few inline module plots but does not provide full parity with the published example pages.

```shell
make SPHINXBUILD="python -m sphinx" html-noplot
```

--------------------------------

### Install tick via pip

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Installs the tick package from PyPI. Building C++ extensions may take a few minutes.

```bash
pip install tick
```

--------------------------------

### Install wheel files with pip

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Installs the downloaded wheel files on Windows. Not required for Anaconda.

```bash
pip install wheel
pip install numpy-1.13.*+mkl-cp36-cp36m-win_amd64.whl
pip install numpydoc-0.7.0-py2.py3-none-any.whl
pip install scipy-0.19.*-cp36-cp36m-win_amd64.whl
```

--------------------------------

### Install Python dependencies with pip

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Installs the required Python dependencies listed in requirements/runtime.txt. Use this if not installing via pip.

```bash
pip install -r requirements/runtime.txt
```

--------------------------------

### In-place editable installation for developers

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Installs tick in editable mode so extensions are built inside the source directory, avoiding reinstallation for each code change.

```bash
python -m pip install -e .[dev]
```

--------------------------------

### Automated Windows installation script

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Runs the automated Windows installation script, which requires CYGWIN or MSYS and manually downloaded wheel files.

```bash
./tools/windows/install.sh
```

--------------------------------

### Setup reticulate and import tick in R

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/R.rst

Initializes reticulate and imports tick from a specified Python path. Replace SOMEPATH1 with the path to the Python 3 binary and SOMEPATH2 with the path to the tick installation.

```R
library('reticulate')
reticulate::use_python('SOMEPATH1/python3')
tick = import_from_path('tick', 'SOMEPATH2/tick/')
```

--------------------------------

### SVRG solver example with logistic regression and elastic-net

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/solver.rst

Shows how to set up a model, prox, and solver, then solve for the minimizer. The step size is automatically tuned using 1 / model.get_lip_max(). The output shows the solver's progress and the found minimizer.

```python
import numpy as np
from tick.linear_model import SimuLogReg, ModelLogReg
from tick.simulation import weights_sparse_gauss
from tick.solver import SVRG
from tick.prox import ProxElasticNet

n_samples, n_features = 5000, 10
weights0 = weights_sparse_gauss(n_weights=n_features, nnz=3)
intercept0 = 1.
X, y = SimuLogReg(weights0, intercept=intercept0, seed=123,
                  n_samples=n_samples, verbose=False).simulate()

model = ModelLogReg(fit_intercept=True).fit(X, y)
prox = ProxElasticNet(strength=1e-3, ratio=0.5, range=(0, n_features))

svrg = SVRG(tol=0., max_iter=5, print_every=1).set_model(model).set_prox(prox)
x0 = np.zeros(model.n_coeffs)
minimizer = svrg.solve(x0, step=1 / model.get_lip_max())
print("\nfound minimizer\n", minimizer)
```

```none
Launching the solver SVRG...
  n_iter  |    obj    |  rel_obj
        1 |  5.01e-01 |  5.15e-02
        2 |  4.97e-01 |  8.44e-03
        3 |  4.97e-01 |  5.00e-04
        4 |  4.97e-01 |  2.82e-05
        5 |  4.97e-01 |  7.28e-07

Done solving using SVRG in 0.03281998634338379 seconds

found minimizer
 [ 0.01992683  0.00456966 -0.16595686 -0.08619878  0.01059461  0.6144692
  0.0049031  -0.07767023  0.07550217  1.18493663  0.9424508 ]
```

--------------------------------

### Download Visual Studio Build Tools

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

URL to download Microsoft Visual Studio Build Tools for Windows installation.

```text
https://www.visualstudio.com/downloads/#build-tools-for-visual-studio-2019
```

--------------------------------

### CMake project setup with C++17 and fast-math option

Source: https://github.com/x-datainitiative/tick/blob/master/lib/CMakeLists.txt

Initializes the tick project with CMake 3.7, sets C++17 standard, and defines the TICK_ENABLE_FAST_MATH option (default ON) which adds /fp:fast on MSVC or -ffast-math otherwise.

```cmake
cmake_minimum_required(VERSION 3.7)
project(tick)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

option(TICK_ENABLE_FAST_MATH "Enable fast-math compiler flags" ON)

if (TICK_ENABLE_FAST_MATH)
    if (MSVC)
        add_compile_options(/fp:fast)
    else ()
        add_compile_options(-ffast-math)
    endif ()
endif ()
```

--------------------------------

### Metaclass property creation example (testcode)

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/dev.rst

Defines a class A inheriting from Base that sets an attribute in __init__. This is used to illustrate how properties are automatically created for each attribute, linking to a hidden attribute with a double underscore prefix.

```python
class A(Base):
    def __init__(self, attr):
        self.attr = attr
```

--------------------------------

### Function using ArrayDouble as input

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Example of a C++ function that accepts an ArrayDouble reference and computes the sum of its elements.

```cpp
 // File test.cpp
 #include "base.h"
 
 // Computes the sum of the array
 double test_array_double(ArrayDouble &array)  
 {
	  double sum = 0;

	  for (long i=0; i<array.size(); i++)
		  sum += array[i];

	  return(sum);
 }
```

--------------------------------

### Download required wheel files

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Lists the wheel files to download from the provided URL for Windows installation. Not required for Anaconda.

```text
numpy-1.13.*+mkl-cp36-cp36m-win_amd64.whl
numpydoc-0.7.0-py2.py3-none-any.whl
scipy-0.19.*-cp36-cp36m-win_amd64.whl
```

--------------------------------

### Clone tick repository

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Clones the tick GitHub repository for manual installation.

```bash
git clone https://github.com/X-DataInitiative/tick.git
```

--------------------------------

### CMake testing setup with GTest and Python

Source: https://github.com/x-datainitiative/tick/blob/master/lib/CMakeLists.txt

Finds GTest, enables testing if found, requires Threads and Python 3.7, includes GTest headers, and sets test libraries including BLAS and pthread. On Apple, adds Accelerate framework.

```cmake
find_package(GTest)

if (${GTEST_FOUND})
    enable_testing()
    message(STATUS "Testing in C++ enabled")

    find_package(Threads REQUIRED)
    find_package(PythonInterp 3.7 REQUIRED)
    find_package(PythonLibs 3.7 REQUIRED)

    include_directories(${GTEST_INCLUDE_DIRS})

    set(TICK_TEST_LIBS
            ${PYTHON_LIBRARY}
            ${GTEST_BOTH_LIBRARIES}
            ${CMAKE_THREAD_LIBS_INIT}
            ${TICK_BLAS_LIBRARIES} pthread)

    if (APPLE)
        find_library(ACCELERATE_LIBRARY Accelerate)

        mark_as_advanced(ACCELERATE_LIBRARY)
        set(TICK_TEST_LIBS ${TICK_TEST_LIBS} ${ACCELERATE_LIBRARY})
    endif ()
endif ()
```

--------------------------------

### CMake macOS install RPATH configuration

Source: https://github.com/x-datainitiative/tick/blob/master/lib/CMakeLists.txt

On Apple platforms, sets install RPATH to include build directories of all tick components and enables install RPATH usage.

```cmake
if (APPLE)
    set(TICK_INSTALL_RPATH "${CMAKE_CURRENT_SOURCE_DIR}/../tick/array/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/base/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/base_model/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/linear_model/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/random/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/prox/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/solver/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/hawkes/inference/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/hawkes/model/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/hawkes/simulation/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/robust/build;${CMAKE_CURRENT_SOURCE_DIR}/../tick/survival/build;${TICK_EXTRA_RPATH}")

    set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
    set(CMAKE_INSTALL_RPATH "${TICK_INSTALL_RPATH}")
endif (APPLE)
```

--------------------------------

### ArrayDouble initialization and view operations

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Demonstrates creating, copying, and creating views of ArrayDouble objects in C++.

```cpp
ArrayDouble c(10); 				  // Creates an array of double of size 10, initialized with 0's
ArrayDouble c = ArrayDouble(10);  // Strictly equivalent to the line above
ArrayDouble b = c; 				  // Creates an array b which is a copy of c (so the data are copied)
ArrayDouble d = c.view() 	      // Creates a view that shares the data with c (Be sure c is desallocated first !), Data are not copied
b = c.view()                  // with this line, the data of b are deleted and then b and c share there data
ArrayDouble e = c.view(1,5)       // Here e is a view on c starting at index 1 up to index 5 (excluded).
```

--------------------------------

### Create and resize VArrayDoublePtr

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Creating a resizeable VArray and resizing it in place.

```cpp
VArrayDoublePtr a = VArrayDouble::new_ptr();
```

```cpp
a->set_size(100);
```

--------------------------------

### Setting allowed attributes works

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/dev.rst

Shows that documented parameters, documented attributes, and __init__ arguments can be set.

```python
>>> a = A(10, 12)
>>> a.documented_parameter = 32
>>> a.documented_attribute = 'bananas'
>>> a.undocumented_parameter = 'are too many'
>>> a.documented_parameter, a.documented_attribute, a.undocumented_parameter
(32, 'bananas', 'are too many')
```

--------------------------------

### Create and print ProxL1 with default parameters

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/prox.rst

Creates a ProxL1 instance with strength 1e-2 and prints its representation. The output shows the default parameters: dtype float64, positive false, range null, and strength 0.01.

```python
import numpy as np
from tick.prox import ProxL1

prox = ProxL1(strength=1e-2)
print(prox)
```

```output
{
  "dtype": "float64",
  "name": "ProxL1",
  "positive": false,
  "range": null,
  "strength": 0.01
}
```

--------------------------------

### Modify VArrayPtr in C++

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Example of modifying a VArrayDoublePtr in place and duplicating its values.

```cpp
// File test.cpp
#include "base.h"

double test_varrayptr_double(VArrayDoublePtr varrayptr)
{
    varrayptr->set_size(varrayptr->size()*2,true);

    for (unsigned long i=0; i<varrayptr->size(); i++)
        varrayptr[i+varrayptr->size()] = varrayptr[i];

    return(varrayptr);
}
```

--------------------------------

### SharedArrayPtr manipulation in C++

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Example of modifying a shared array and maintaining a reference in C++.

```cpp
static SArrayDoublePtr reference; // We can keep a refence in the C++ code it is not a problem
SArrayDoublePtr  f (SArrayDoublePtr sarray, double factor)
{
	for (long i=0;i<sarray->size();i++) {
		(*sarray)[i] *= factor;
	}
	reference = sarray;
	return sarray
}
```

--------------------------------

### Initialize git submodules

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Initializes and updates submodules such as cereal after cloning.

```bash
git submodule update --init
```

--------------------------------

### Inefficient SharedArray creation

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Example of an inefficient approach that causes a data copy when creating a SArrayDoublePtr from an ArrayDouble.

```cpp
static SArrayDoublePtr reference; // We can keep a refence in the C++ code it is not a problem
SArrayDoublePtr  f (ArrayDouble &a, double factor)
{
	for (long i=0;i<a.get_size();i++) {
		a[i] *= factor;
	}
	reference = SArrayDouble::new_ptr(a); // HERE WE COPY THE DATA !

	return reference
}
```

--------------------------------

### Function using ArrayDouble2d as input

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Example of a C++ function that computes the sum of a specific row in an ArrayDouble2d object.

```cpp
 // File test2.cpp
 #include "base.h"
 
 // Computes the sum of the ith row of the 2d array
 double test_array_double(ArrayDouble2d &array, int i)  
 {
	  double sum = 0;
	  ArrayDouble row = array.view_row(i);

	  for (long i=0; i<row.size(); i++)
		  sum += row[i];

	  return(sum);
 }
```

--------------------------------

### Export Visual Studio environment variables

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Command to set up Visual Studio environment variables for the target architecture.

```bash
/path/to/VS/VC/Auxiliary/Build/vcvarsall.bat [amd64,x86]
```

--------------------------------

### Create and print ProxL1 with range and positive=True

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/prox.rst

Creates a ProxL1 with strength 1e-2, range (0, 30), and positive=True, then prints it. The output shows positive true and range [0, 30].

```python
prox = ProxL1(strength=1e-2, range=(0, 30), positive=True)
print(prox)
```

```output
{
  "dtype": "float64",
  "name": "ProxL1",
  "positive": true,
  "range": [
    0,
    30
  ],
  "strength": 0.01
}
```

--------------------------------

### Compiler warning for deprecated code

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/dev.rst

Example warning output when using TICK_DEPRECATED. Code still compiles and links but generates warnings.

```text
.../tick/deprecated.cpp: In member function ‘void f()’:
.../tick/deprecated.cpp:20:3: warning: ‘int some_method()’ is deprecated (declared at .../deprecated.cpp:10) [-Wdeprecated-declarations]
```

--------------------------------

### Define tick_matrix_vector_product executable and link libraries

Source: https://github.com/x-datainitiative/tick/blob/master/tools/benchmark/lib/CMakeLists.txt

Creates the tick_matrix_vector_product benchmark executable from matrix_vector_product.cpp and links it with base, array, crandom, and test libraries.

```cmake
add_executable(tick_matrix_vector_product matrix_vector_product.cpp)
target_link_libraries(tick_matrix_vector_product
        ${TICK_LIB_BASE}
        ${TICK_LIB_ARRAY}
        ${TICK_LIB_CRANDOM}
        ${TICK_TEST_LIBS}
        )
```

--------------------------------

### C++ class with interruptible method and non-parallel test

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Defines TestInterrupt with a test method that calls Interruption::throw_if_raised() in a loop, and a non-parallel test function test_interrupt that runs it. This is the first example from interruption_test.cpp.

```cpp
// A class with an intensive (stupid) method that can be interrupted
class TestInterrupt {

    public :

    TestInterrupt() {};

    void test(unsigned long i) {
        int res = 0;
        for (int j = 0; j< 1000000; j++) {
            Interruption::throw_if_raised();
            for (int k = 0; k< 1000000; k++) {
                res += 1;
                res = res % 100;
            }
        }
    }
};

// A standard non parallel test
void test_interrupt()
{
    TestInterrupt ti;
    for (int i = 0; i< 1000000; i++)
        ti.test(i);
}
```

--------------------------------

### Build and test tick on Windows

Source: https://github.com/x-datainitiative/tick/blob/master/INSTALL.md

Builds tick with dev dependencies and runs the test suite.

```bash
python -m pip install .[dev]
python -m pytest -q
```

--------------------------------

### Create and Inspect Logistic Regression Model

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/linear_model.rst

Initialize a logistic regression model, fit it to the data, and print its configuration.

```python
import numpy as np
from tick.linear_model import ModelLogReg

model = ModelLogReg(fit_intercept=True).fit(X, y)
print(model)
```

```text
{
  "dtype": "float64",
  "fit_intercept": true,
  "n_calls_grad": 0,
  "n_calls_loss": 0,
  "n_calls_loss_and_grad": 0,
  "n_coeffs": 51,
  "n_features": 50,
  "n_passes_over_data": 0,
  "n_samples": 2000,
  "n_threads": 1,
  "name": "ModelLogReg"
}
```

--------------------------------

### CMake options for MKL, BLAS, and benchmarks

Source: https://github.com/x-datainitiative/tick/blob/master/lib/CMakeLists.txt

Defines options USE_MKL, USE_BLAS, and BENCHMARK (all OFF by default). Sets up variables for BLAS libraries and extra RPATH.

```cmake
include_directories(${CMAKE_SOURCE_DIR}/..)

option(USE_MKL "Force tick to use MKL" OFF)
option(USE_BLAS "Force tick to use BLAS" OFF)
option(BENCHMARK "Build benchmarks" OFF)

set(TICK_EXTRA_RPATH "")
set(TICK_BLAS_LIBRARIES "")
```

--------------------------------

### Set C++ attribute via Python property (doctest)

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/dev.rst

Shows that assigning to a Python attribute (cpp_int) calls the C++ setter and updates the underlying C++ value. The example uses class A from tick.base.utils.build.utils (import as A0).

```python
>>> a = A()
>>> a.cpp_int, a._a.get_cpp_int()
(0, 0)
>>> a.cpp_int = -4
>>> a.cpp_int, a._a.get_cpp_int()
(-4, -4)
```

--------------------------------

### Train logistic regression with elastic-net in R

Source: https://github.com/x-datainitiative/tick/blob/master/doc/modules/R.rst

Downloads the adult dataset, trains a logistic regression with elastic-net penalization, and plots the ROC curve on the testing set using scikit-learn metrics. Requires sklearn.metrics installed in the Python distribution.

```R
# Fetch data
fetch_tick_dataset = tick$dataset$fetch_tick_dataset
train_set = fetch_tick_dataset('binary/adult/adult.trn.bz2')
test_set = fetch_tick_dataset('binary/adult/adult.tst.bz2')

# Logistic regression training
LogisticRegression = tick$linear_model$LogisticRegression
clf = LogisticRegression(penalty='elasticnet')
clf$fit(train_set[[1]], train_set[[2]])

# Plot of the ROC curve on the testing set using scikit-learn
metrics = import('sklearn.metrics')
predictions = clf$predict_proba(test_set[[1]])
res = metrics$roc_curve(test_set[[2]], predictions[, 2])
fpr = res[[1]]
tpr = res[[2]]
plot(fpr, tpr, type='l')
```

--------------------------------

### Define tick_asaga_sparse executable and link libraries

Source: https://github.com/x-datainitiative/tick/blob/master/tools/benchmark/lib/CMakeLists.txt

Creates the tick_asaga_sparse benchmark executable from asaga_sparse.cpp and links it with the same set of libraries as tick_saga_sparse.

```cmake
add_executable(tick_asaga_sparse asaga_sparse.cpp)
target_link_libraries(tick_asaga_sparse
        ${TICK_LIB_BASE}
        ${TICK_LIB_ARRAY}
        ${TICK_LIB_CRANDOM}
        ${TICK_LIB_BASE_MODEL}
        ${TICK_LIB_LINEAR_MODEL}
        ${TICK_LIB_PROX}
        ${TICK_LIB_SOLVER}
        ${TICK_TEST_LIBS}
        )
```

--------------------------------

### C++ parallel test using parallel_run with interruptible method

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Defines the same TestInterrupt class and a parallel test function test_interrupt_parallel that uses parallel_run(4,1000000,&TestInterrupt::test,&ti) to run the test across 4 threads. This is the second example from interruption_test.cpp.

```cpp
// A class with an intensive (stupid) method that can be interrupted
class TestInterrupt {

    public :

    TestInterrupt() {};

    void test(unsigned long i) {
        int res = 0;
        for (int j = 0; j< 1000000; j++) {
            Interruption::throw_if_raised();
            for (int k = 0; k< 1000000; k++) {
                res += 1;
                res = res % 100;
            }
        }
    }
};


// A parallel test
void test_interrupt_parallel()
{
    TestInterrupt ti;
    parallel_run(4,1000000,&TestInterrupt::test,&ti);
}
```

--------------------------------

### Define linear_system executable and link libraries

Source: https://github.com/x-datainitiative/tick/blob/master/lib/cpp-test/array/CMakeLists.txt

Creates the linear_system executable from linear_system_gtest.cpp and links it with TICK_LIB_ARRAY and TICK_TEST_LIBS.

```cmake
add_executable(linear_system linear_system_gtest.cpp)
target_link_libraries(linear_system
        ${TICK_LIB_ARRAY}
        ${TICK_TEST_LIBS}
        )
```

--------------------------------

### Expose VArrayPtr to Python

Source: https://github.com/x-datainitiative/tick/blob/master/lib/doc/mainpage.dox

Steps to expose a C++ function to Python using a header file, binding declaration, and usage in Python.

```cpp
// File test.h

extern double test_varrayptr_double(VArrayDoublePtr array);
```

```unparsed
%{
#include "tick_python.h"
#include "test.h"
%}
```

```py
import numpy
test_array_double(numpy.array([1.,2,3,4]))
```
Tokens:
Raw