mooreniemi

# https://github.com/matsui528/faiss_tips
import faiss
import numpy as np

D = 256
N = 10000
X = np.random.random((N, D)).astype(np.float32)

# Setup
index = faiss.index_factory(D, "IVF25,Flat", faiss.METRIC_INNER_PRODUCT)

mooreniemi

use std::{
    fs::File,
    io::{BufRead, BufReader},
    path::PathBuf,
    time::Instant,
};

use faiss::{error::Error, index_factory, read_index, write_index, Index, MetricType};
use itertools_num::linspace;
use structopt::StructOpt;

mooreniemi

use std::{path::PathBuf, time::Instant};

use faiss::{error::Error, index_factory, read_index, write_index, Index, MetricType};
use itertools_num::linspace;
use structopt::StructOpt;

#[derive(Debug, StructOpt)]
#[structopt(name = "dann", about = "Demo ANN")]
struct DannOpt {
    /// FAISS Index factory string

mooreniemi

use std::time::Instant;

use faiss::{error::Error, index_factory, Index, MetricType};
use itertools_num::linspace;

fn main() -> Result<(), Error> {
    let d: u32 = 64;
    // let my_data: Vec<f32> = (1u16..(d * 10) as u16).map(f32::from).collect();
    // above way of generating f32 ranges is limited in d size wrt default traits
    // https://users.rust-lang.org/t/collect-f32-range-into-a-vector/15936/3

mooreniemi

use faiss::{error::Error, index_factory, Index, MetricType};
fn main() -> Result<(), Error> {
    let my_data = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
    let mut index = index_factory(8, "Flat", MetricType::L2)?;
    index.add(&my_data)?;
    let result = index.search(&my_data, 5)?;
    for (i, (l, d)) in result
        .labels
        .iter()
        .zip(result.distances.iter())

mooreniemi

#![deny(warnings)]
use std::{collections::HashMap, convert::Infallible, sync::Arc};
use tokio::sync::RwLock;
use warp::{Filter, Rejection};

fn with_store(
    store: Arc<RwLock<HashMap<String, u64>>>,
) -> impl Filter<Extract = (Arc<RwLock<HashMap<String, u64>>>,), Error = Infallible> + Clone {
    warp::any().map(move || store.clone())
}

mooreniemi

#![deny(warnings)]
use std::{collections::HashMap, convert::Infallible, str::FromStr, sync::Arc};
use tokio::sync::RwLock;
use warp::{Filter, Rejection};

fn with_store(
    store: Arc<RwLock<HashMap<String, u64>>>,
) -> impl Filter<Extract = (Arc<RwLock<HashMap<String, u64>>>,), Error = Infallible> + Clone {
    warp::any().map(move || store.clone())
}

mooreniemi

import math

def permutations(to_go, path_taken='', paths=[]):
    if not to_go:
        print(path_taken)
        paths.append(path_taken)
    else:
        for i in range(len(to_go)):
            here = to_go[i]
            elsewhere = to_go[:i] + to_go[i+1:]

mooreniemi

cjson = require "cjson"
ngx. req. read_body()                                       -- explicitly read the req body
local data = ngx. req. get_body_data()
local jsonBody = cjson. decode(data);
if data then
  local reqs = { }
  --ngx. say("body data:")

  for key, value in pairs(jsonBody) do
    --ngx.print(key)

mooreniemi

# a script to load seshat data into Elasticsearch
# seshat data is clearly graphdb data, but ES is nifty, so...
# assumes you have set up elasticsearch and kibana

import pandas as pd
from elasticsearch import Elasticsearch
from elasticsearch.helpers import parallel_bulk

# assumes local ES
es = Elasticsearch()