Skip to main content
Back

California's AI Bill is Now Altered

READ MORE

August 19, 2024 5 min read

Hey,

Welcome to today's edition of AlphaSignal, a newsletter for developers by developers.

We identify and summarize the top 1% news, papers, models, and repos in the AI industry. 

IN TODAY'S SIGNAL

Read time: 5 min 39 sec

🎖️ Top News

📌 AI Conference

⚡️ Trending Signals


⚙️ Top Tutorials

🧠 Tutorial

  • How to use the new structured output with OpenAI.

If you're enjoying AlphaSignal please forward this email to a colleague. 

It helps us keep this content free.

TOP NEWS

AI Safety Policy

California compromises on AI safety bill, SB 1047, significant opposition from many parties in Silicon Valley

⇧ 1,573 Likes

What's New

California's AI safety bill, SB 1047 passed committee with some significant amendments. It still aims to prevent AI disasters by holding developers liable, but now grants less power to the government to regulate AI labs.

The bill targets models capable of causing cybersecurity incidents with over $500 million in damages or loss of human life, by holding developers liable.


Key points of these recent amendments

  • Attorney General can no longer sue for negligent practices before an event occurs

  • Public "statements" on safety practices replace certifications "under penalty of perjury"

  • Standard changed from "reasonable assurance" to "reasonable care" for model safety

  • Protection for open source fine-tuned models, with developers spending less than $10 million on fine-tuning are exempt from liability. i.e. they are explicitly not considered a developer by SB 1047.

  • Board of Frontier Models created within Government Operations Agency

  • The nine-member Board of Frontier Models will set compute thresholds, issue safety guidance, and regulate auditors.  

It is unclear how Meta could guarantee that they were not liable for a model they release as open-sourced. Meta could still be held liable for damages caused by a fine-tuned Llama model.


The bill faces opposition from U.S. congressmen, AI researchers, and tech companies. It now heads to California's Assembly floor for a final vote, followed by a return to the Senate due to recent amendments. 

Read more

Win two free passes to The AI Conference 2024

Join the AI Conference for 2 full days with top leaders from OpenAI, Meta, Google, The Pentagon and many more:

  • 2 Days | 75+ Speakers | 3 Tracks

  • Top AI Companies Exhibiting in Expo

  • AI Impact in Healthcare, Enterprise, Defense + More

  • Live AI Startup Competition with VC Judges

  • Speaker Office Hours - Meaningful Networking

  • AI After Dark Networking Mixer + Expo Booth Crawl

Winners Announced Friday

Enter to win

partner with us

TRENDING SIGNALS

Computer Vision Models

Huggingface showcased a demo for BiRefNet, for free image background removal, with only 5.5GB GPU memory MIT licensed model

⇧ 566 Likes

Video Generation

New open-Sourced Gihtub code for translating video from one language to another with dubbing, with a tiny 1.9GB model

⇧ 551 Likes

LLM Agents

New Paper shows that we can use agents to invent novel and powerful agent designs by programming in code

⇧ 243 Likes

Speech Generation

New open-sourced code to run GPT4o-like Speech-to-Speech models on device, 100% private and up to 500 ms latency

⇧ 290 Likes

AI Paper

New AI Paper solves Rubik’s Cube faster starting from a scrambled Rubik’s Cube

⇧ 68 Likes

TOP LECTURES

Agent

Build a multi-agent system for automated research and report generation

⇧ 293 Likes

Helps you to use LlamaParse to build a multi-agent system that can do research over a multimodal RAG automatically. It uses text and image indexing, implement multimodal RAG with dynamic chunk and document retrieval. Also learn to orchestrate async, event-driven workflows with LlamaIndex, and generate structured outputs with interleaved text and images.

GPU

Calculating GPU memory for serving LLMs

⇧ 3100 Likes

This tutorial explains a clean formula to determine required GPU memory based on model size and quantization. You'll see examples for Llama 2 70B at different precisions. Understand how quantization reduces memory usage.

LLM Traning

New LLM Pre-training and Post-training Paradigms

⇧ 1905 Likes

Learn to examine LLM training techniques used by Alibaba, Apple, Google, and Meta. You'll understand multi-stage pre-training, knowledge distillation, and various post-training approaches. The tutorial covers data quality strategies, context lengthening (e.g. from 4,096 to 32,768 tokens), and model averaging.

TUTORIAL

OpenAI

How to use the new structured output with OpenAI SDKs

Around ten days back, OpenAI released the new gpt-4o-mini and gpt-4o-2024-08-06 models, which supports Structured JSON Outputs.


Here's a brief step-by-step tutorial on integrating structured outputs with OpenAI SDKs.

  • Install OpenAI SDK with `pip install openai -U`.

  • Import necessary libraries like `json` and `openai`.

  • Create an OpenAI client instance using `client = OpenAI()`.


  • You can use Structured Outputs in two ways:


    a) When you use function calling, supply `strict: true` within your function definition to ensure that the model’s output will match your exact schema.

    b) You can now supply a `json_schema` as a `response_format` option, along with a full definition of your schema. Set `strict: true` to ensure that model outputs will reliably match your schema.

  • In the example code below we implement the option b above, using a `json_schema` for the `response_format` option and `strict: true`

  • Use `client.chat.completions.create()` to send a request, including the model, messages, and response format.

  • Extract and parse the structured response from `response.choices.message`.


!pip install openai -U

import json
from textwrap import dedent
from openai import OpenAI
client = OpenAI()

MODEL = "gpt-4o-2024-08-06"

math_tutor_prompt = """
    You are a helpful math tutor. You will be provided
    with a math problem, and your goal will be to output
    a step by step solution,along with a final answer.
    For each step, just provide the output as an
    equation use the explanation field to detail the
    reasoning."""

def get_math_solution(question):
    response = client.chat.completions.create(
    model=MODEL,
    messages=[
        ,
        
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "math_reasoning",
            "schema": {
                "type": "object",
                "properties": {
                    "steps": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "explanation": ,
                                "output":
                            },
                            "required": ["explanation",
                                         "output"],
                            "additionalProperties":
                            False
                        }
                    },
                    "final_answer":
                },
                "required": ["steps", "final_answer"],
                "additionalProperties": False
            },
            "strict": True
        }
    }
    )

    return response.choices[0].message

# Testing with an example question
question = "how can I solve 8x + 7 = -23"

result = get_math_solution(question)

print(result.content)
# this will print a guaranteed `json_schema`
# as defined above

Google colab for this code

Thank You.

Want to promote your company, product, service, or event to 190,000+ AI researchers and engineers?

Sponsor