younesbelkada

# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software

omar-3

marcrasi

// MARK: - Some differentiable array manipulation functions used in the algorithms.

extension Array where Element: Differentiable {
  @differentiable(vjp: _vjpSwappedAt)
  func swappedAt(_ i: Int, _ j: Int) -> Array {
    var tmp = self
    tmp.swapAt(i, j)
    return tmp
  }

snakers4

import gc
import tqdm
import faiss
import bcolz
import os,sys
import numpy as np
from tqdm import tqdm

# open the stored bcolz array
# note that these vectors have to be 280 dimensional

davideicardi

/*
https://scalafiddle.io/sf/sniohcZ/3
(old version: https://scalafiddle.io/sf/sniohcZ/1)

Use PassThroughFlow when you have a message that should be used in a 
flow that trasform it but you want to maintain the original message for
another following flow.
For example if you consume messages from Kafka (CommittableMessage).
You process the message (transform, save it inside a database, ...) and then you need again the original message 
to commit the offset.

koen-dejonghe

package scorch.examples

import botkop.numsca.Tensor
import botkop.{numsca => ns}
import scorch.autograd._
import scorch.nn.rnn.RecurrentModule
import scorch.nn.Optimizer

import scala.annotation.tailrec
import scala.io.Source

lattner

Swift Concurrency Manifesto

Author: Chris Lattner

Chinese Translation by Jason Yu

Contents

• Introduction
• Overall Vision

koen-dejonghe

      case class SomeEvent(value: Long)

      val events = Source
        .tick(0 seconds, 250 millis, "")
        .zipWithIndex
        .map { case (_, l) =>
            SomeEvent(l)
        }

      val group = Flow[SomeEvent].groupedWithin(100, 500 millis) // +/- 2 events per group

adamw

package com.softwaremill.akka

import java.time._

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.stream.scaladsl.Source

import scala.collection.mutable
import scala.concurrent.Await

kylemcdonald

import PIL.Image
from cStringIO import StringIO
import IPython.display
import numpy as np
def showarray(a, fmt='png'):
    a = np.uint8(a)
    f = StringIO()
    PIL.Image.fromarray(a).save(f, fmt)
    IPython.display.display(IPython.display.Image(data=f.getvalue()))